1 /*
2  * Copyright (c) 2021-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 "napi_os_account_common.h"
17 #include <string>
18 #include "napi_account_error.h"
19 #include "napi_account_common.h"
20 #include "napi/native_common.h"
21 #include "napi_os_account.h"
22 
23 namespace OHOS {
24 namespace AccountJsKit {
25 constexpr int32_t COMPATIBILITY_CHANGE_VERSION_API12 = 12;
NapiCreateDomainCallback(napi_env env,napi_ref callbackRef,napi_deferred deferred)26 NapiCreateDomainCallback::NapiCreateDomainCallback(napi_env env, napi_ref callbackRef, napi_deferred deferred)
27     : env_(env), callbackRef_(callbackRef), deferred_(deferred)
28 {}
29 
OnResult(const int32_t errCode,Parcel & parcel)30 void NapiCreateDomainCallback::OnResult(const int32_t errCode, Parcel &parcel)
31 {
32     std::shared_ptr<OsAccountInfo> osAccountInfo(OsAccountInfo::Unmarshalling(parcel));
33     if (osAccountInfo == nullptr) {
34         ACCOUNT_LOGE("failed to unmarshalling OsAccountInfo");
35         return;
36     }
37     std::unique_lock<std::mutex> lock(lockInfo_.mutex);
38     if ((callbackRef_ == nullptr) && (deferred_ == nullptr)) {
39         ACCOUNT_LOGE("js callback is nullptr");
40         return;
41     }
42     uv_loop_s *loop = nullptr;
43     uv_work_t *work = nullptr;
44     if (!CreateExecEnv(env_, &loop, &work)) {
45         ACCOUNT_LOGE("failed to init domain plugin execution environment");
46         return;
47     }
48     auto *asyncContext = new (std::nothrow) CreateOAForDomainAsyncContext();
49     if (asyncContext == nullptr) {
50         delete work;
51         return;
52     }
53     asyncContext->osAccountInfos = *osAccountInfo;
54     asyncContext->errCode = errCode;
55     asyncContext->env = env_;
56     asyncContext->callbackRef = callbackRef_;
57     asyncContext->deferred = deferred_;
58     work->data = reinterpret_cast<void *>(asyncContext);
59     int resultCode = uv_queue_work_with_qos(
60         loop, work, [](uv_work_t *work) {}, CreateOAForDomainCallbackCompletedWork, uv_qos_default);
61     if (resultCode != 0) {
62         ACCOUNT_LOGE("failed to uv_queue_work_with_qos, errCode: %{public}d", errCode);
63         delete asyncContext;
64         delete work;
65         return;
66     }
67     callbackRef_ = nullptr;
68     deferred_ = nullptr;
69 }
70 
WrapVoidToJS(napi_env env)71 napi_value WrapVoidToJS(napi_env env)
72 {
73     napi_value result = nullptr;
74     NAPI_CALL(env, napi_get_null(env, &result));
75     return result;
76 }
77 
ParseOneParaContext(napi_env env,napi_callback_info cbInfo,CommonAsyncContext * asyncContext)78 static bool ParseOneParaContext(napi_env env, napi_callback_info cbInfo, CommonAsyncContext *asyncContext)
79 {
80     size_t argc = ARGS_SIZE_ONE;
81     napi_value argv[ARGS_SIZE_ONE] = {0};
82     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
83     if (argc == ARGS_SIZE_ONE) {
84         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
85             ACCOUNT_LOGE("Get callbackRef failed");
86             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
87             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
88             return false;
89         }
90     }
91     return true;
92 }
93 
ParseCallbackAndId(napi_env env,napi_callback_info cbInfo,napi_ref & callbackRef,int & id,bool throwErr)94 bool ParseCallbackAndId(napi_env env, napi_callback_info cbInfo, napi_ref &callbackRef, int &id, bool throwErr)
95 {
96     size_t argc = ARGS_SIZE_TWO;
97     napi_value argv[ARGS_SIZE_TWO] = {0};
98     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
99 
100     if (argc == ARGS_SIZE_TWO) {
101         if (!GetCallbackProperty(env, argv[argc - 1], callbackRef, 1)) {
102             ACCOUNT_LOGE("Get callbackRef failed");
103             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
104             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, throwErr);
105             return false;
106         }
107     }
108     if (!GetIntProperty(env, argv[PARAMZERO], id)) {
109         ACCOUNT_LOGE("Get id failed");
110         std::string errMsg = "Parameter error. The type of \"localId\" must be number";
111         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, throwErr);
112         return false;
113     }
114     return true;
115 }
116 
ParseParaDeactivateOA(napi_env env,napi_callback_info cbInfo,ActivateOAAsyncContext * asyncContext)117 bool ParseParaDeactivateOA(napi_env env, napi_callback_info cbInfo, ActivateOAAsyncContext *asyncContext)
118 {
119     size_t argc = ARGS_SIZE_ONE;
120     napi_value argv[ARGS_SIZE_ONE] = {0};
121     NAPI_CALL_BASE(env, napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr), false);
122 
123     if (argc < ARGS_SIZE_ONE) {
124         ACCOUNT_LOGE("The number of parameters should be at least 1.");
125         std::string errMsg = "The number of parameters should be at least 1";
126         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, true);
127         return false;
128     }
129     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
130         ACCOUNT_LOGE("Get local Id failed.");
131         std::string errMsg = "The type of first arg must be number";
132         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, true);
133         return false;
134     }
135     return true;
136 }
137 
DeactivateOAExecuteCB(napi_env env,void * data)138 void DeactivateOAExecuteCB(napi_env env, void *data)
139 {
140     ActivateOAAsyncContext *asyncContext = reinterpret_cast<ActivateOAAsyncContext *>(data);
141     asyncContext->errCode = OsAccountManager::DeactivateOsAccount(asyncContext->id);
142 }
143 
DeactivateOACompletedCB(napi_env env,napi_status status,void * data)144 void DeactivateOACompletedCB(napi_env env, napi_status status, void *data)
145 {
146     ActivateOAAsyncContext *asyncContext = reinterpret_cast<ActivateOAAsyncContext *>(data);
147     std::unique_ptr<ActivateOAAsyncContext> asyncContextPtr{asyncContext};
148     napi_value errJs = nullptr;
149     napi_value dataJs = nullptr;
150     if (asyncContext->errCode == ERR_OK) {
151         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &dataJs));
152     } else {
153         errJs = GenerateBusinessError(env, asyncContext->errCode);
154     }
155     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
156 }
157 
ParseParaQueryOAByIdCB(napi_env env,napi_callback_info cbInfo,QueryOAByIdAsyncContext * asyncContext)158 bool ParseParaQueryOAByIdCB(napi_env env, napi_callback_info cbInfo, QueryOAByIdAsyncContext *asyncContext)
159 {
160     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
161 }
162 
QueryOAByIdExecuteCB(napi_env env,void * data)163 void QueryOAByIdExecuteCB(napi_env env, void *data)
164 {
165     QueryOAByIdAsyncContext *asyncContext = reinterpret_cast<QueryOAByIdAsyncContext *>(data);
166     asyncContext->errCode = OsAccountManager::QueryOsAccountById(asyncContext->id, asyncContext->osAccountInfos);
167     ACCOUNT_LOGD("errcode is %{public}d", asyncContext->errCode);
168     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
169 }
170 
QueryOAByIdCallbackCompletedCB(napi_env env,napi_status status,void * data)171 void QueryOAByIdCallbackCompletedCB(napi_env env, napi_status status, void *data)
172 {
173     QueryOAByIdAsyncContext *asyncContext = reinterpret_cast<QueryOAByIdAsyncContext *>(data);
174     napi_value errJs = nullptr;
175     napi_value dataJs = nullptr;
176     if (asyncContext->status == napi_ok) {
177         napi_get_null(env, &errJs);
178         GetOACBInfoToJs(env, asyncContext->osAccountInfos, dataJs);
179     } else {
180         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
181         napi_get_null(env, &dataJs);
182     }
183     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
184     delete asyncContext;
185 }
186 
CreateJsDomainInfo(napi_env env,const DomainAccountInfo & info,napi_value & result)187 void CreateJsDomainInfo(napi_env env, const DomainAccountInfo &info, napi_value &result)
188 {
189     napi_create_object(env, &result);
190     napi_value value = nullptr;
191     // domain
192     napi_create_string_utf8(env, info.domain_.c_str(), info.domain_.size(), &value);
193     napi_set_named_property(env, result, "domain", value);
194 
195     // domain accountName
196     napi_create_string_utf8(env, info.accountName_.c_str(), info.accountName_.size(), &value);
197     napi_set_named_property(env, result, "accountName", value);
198 
199     napi_create_string_utf8(env, info.accountId_.c_str(), info.accountId_.size(), &value);
200     napi_set_named_property(env, result, "accountId", value);
201     if ((info.status_ == DomainAccountStatus::LOGOUT) || (info.status_ >= DomainAccountStatus::LOG_END)) {
202         napi_get_boolean(env, false, &value);
203     } else {
204         napi_get_boolean(env, true, &value);
205     }
206     napi_set_named_property(env, result, "isAuthenticated", value);
207 }
208 
CreateJsDistributedInfo(napi_env env,const OhosAccountInfo & info,napi_value & result)209 void CreateJsDistributedInfo(napi_env env, const OhosAccountInfo &info, napi_value &result)
210 {
211     napi_create_object(env, &result);
212     napi_value value = nullptr;
213     // name
214     napi_create_string_utf8(env, info.name_.c_str(), info.name_.size(), &value);
215     napi_set_named_property(env, result, "name", value);
216 
217     // id
218     napi_create_string_utf8(env, info.uid_.c_str(), info.uid_.size(), &value);
219     napi_set_named_property(env, result, "id", value);
220 
221     // event
222     napi_create_string_utf8(env, "", 0, &value);
223     napi_set_named_property(env, result, "event", value);
224 
225     // scalableData
226     napi_value scalable = nullptr;
227     napi_create_object(env, &scalable);
228     napi_set_named_property(env, result, "scalableData", scalable);
229 }
230 
GetOACBInfoToJs(napi_env env,OsAccountInfo & info,napi_value & objOAInfo)231 void GetOACBInfoToJs(napi_env env, OsAccountInfo &info, napi_value &objOAInfo)
232 {
233     napi_create_object(env, &objOAInfo);
234     napi_value idToJs = nullptr;
235     napi_create_int32(env, info.GetLocalId(), &idToJs);
236     napi_set_named_property(env, objOAInfo, "localId", idToJs);
237 
238     napi_value nameToJs = nullptr;
239     napi_create_string_utf8(env, info.GetLocalName().c_str(), NAPI_AUTO_LENGTH, &nameToJs);
240     napi_set_named_property(env, objOAInfo, "localName", nameToJs);
241 
242     napi_value shortNameToJs = nullptr;
243     napi_create_string_utf8(env, info.GetShortName().c_str(), NAPI_AUTO_LENGTH, &shortNameToJs);
244     napi_set_named_property(env, objOAInfo, "shortName", shortNameToJs);
245 
246     napi_value typeToJsObj = nullptr;
247     napi_create_int32(env, static_cast<int>(info.GetType()), &typeToJsObj);
248     napi_set_named_property(env, objOAInfo, "type", typeToJsObj);
249 
250     napi_value constraintsToJs = nullptr;
251     napi_create_array(env, &constraintsToJs);
252     MakeArrayToJs(env, info.GetConstraints(), constraintsToJs);
253     napi_set_named_property(env, objOAInfo, "constraints", constraintsToJs);
254 
255     napi_value isVerifiedToJs = nullptr;
256     napi_get_boolean(env, info.GetIsVerified(), &isVerifiedToJs);
257     napi_set_named_property(env, objOAInfo, "isVerified", isVerifiedToJs);
258     napi_set_named_property(env, objOAInfo, "isUnlocked", isVerifiedToJs);
259 
260     napi_value photoToJs = nullptr;
261     napi_create_string_utf8(env, info.GetPhoto().c_str(), NAPI_AUTO_LENGTH, &photoToJs);
262     napi_set_named_property(env, objOAInfo, "photo", photoToJs);
263 
264     napi_value createTimeToJs = nullptr;
265     napi_create_int64(env, info.GetCreateTime(), &createTimeToJs);
266     napi_set_named_property(env, objOAInfo, "createTime", createTimeToJs);
267 
268     napi_value lastLoginTimeToJs = nullptr;
269     napi_create_int64(env, info.GetLastLoginTime(), &lastLoginTimeToJs);
270     napi_set_named_property(env, objOAInfo, "lastLoginTime", lastLoginTimeToJs);
271 
272     napi_value serialNumberToJs = nullptr;
273     napi_create_int64(env, info.GetSerialNumber(), &serialNumberToJs);
274     napi_set_named_property(env, objOAInfo, "serialNumber", serialNumberToJs);
275 
276     napi_value isActivedToJs = nullptr;
277     napi_get_boolean(env, info.GetIsActived(), &isActivedToJs);
278     napi_set_named_property(env, objOAInfo, "isActived", isActivedToJs);
279     napi_set_named_property(env, objOAInfo, "isActivated", isActivedToJs);
280 
281     napi_value isLoggedInToJs = nullptr;
282     napi_get_boolean(env, info.GetIsLoggedIn(), &isLoggedInToJs);
283     napi_set_named_property(env, objOAInfo, "isLoggedIn", isLoggedInToJs);
284 
285     napi_value isCreateCompletedToJs = nullptr;
286     napi_get_boolean(env, info.GetIsCreateCompleted(), &isCreateCompletedToJs);
287     napi_set_named_property(env, objOAInfo, "isCreateCompleted", isCreateCompletedToJs);
288 
289     GetOtherAccountInfoToJs(env, info, objOAInfo);
290 }
291 
GetOtherAccountInfoToJs(napi_env env,OsAccountInfo & info,napi_value & objOAInfo)292 void GetOtherAccountInfoToJs(napi_env env, OsAccountInfo &info, napi_value &objOAInfo)
293 {
294     // distributedInfo: distributedAccount.DistributedInfo
295     napi_value dbInfoToJs = nullptr;
296     std::pair<bool, OhosAccountInfo> dbAccountInfo = OhosAccountKits::GetInstance().QueryOhosAccountInfo();
297     if (dbAccountInfo.first) {
298         CreateJsDistributedInfo(env, dbAccountInfo.second, dbInfoToJs);
299     }
300     napi_set_named_property(env, objOAInfo, "distributedInfo", dbInfoToJs);
301 
302     // domainInfo: domainInfo.DomainAccountInfo
303     DomainAccountInfo domainInfo;
304     info.GetDomainInfo(domainInfo);
305     CreateJsDomainInfo(env, domainInfo, dbInfoToJs);
306     napi_set_named_property(env, objOAInfo, "domainInfo", dbInfoToJs);
307 }
308 
MakeArrayToJs(napi_env env,const std::vector<std::string> & constraints,napi_value jsArray)309 void MakeArrayToJs(napi_env env, const std::vector<std::string> &constraints, napi_value jsArray)
310 {
311     uint32_t index = 0;
312 
313     for (auto item : constraints) {
314         napi_value constraint = nullptr;
315         napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &constraint);
316         napi_set_element(env, jsArray, index, constraint);
317         index++;
318     }
319 }
320 
ParseParaRemoveOACB(napi_env env,napi_callback_info cbInfo,RemoveOAAsyncContext * asyncContext)321 bool ParseParaRemoveOACB(napi_env env, napi_callback_info cbInfo, RemoveOAAsyncContext *asyncContext)
322 {
323     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
324 }
325 
RemoveOAExecuteCB(napi_env env,void * data)326 void RemoveOAExecuteCB(napi_env env, void *data)
327 {
328     RemoveOAAsyncContext *asyncContext = reinterpret_cast<RemoveOAAsyncContext *>(data);
329     asyncContext->errCode = OsAccountManager::RemoveOsAccount(asyncContext->id);
330     ACCOUNT_LOGD("errcode is %{public}d", asyncContext->errCode);
331     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
332 }
333 
RemoveOACallbackCompletedCB(napi_env env,napi_status status,void * data)334 void RemoveOACallbackCompletedCB(napi_env env, napi_status status, void *data)
335 {
336     ACCOUNT_LOGD("napi_create_async_work complete");
337     RemoveOAAsyncContext *asyncContext = reinterpret_cast<RemoveOAAsyncContext *>(data);
338     napi_value errJs = nullptr;
339     napi_value dataJs = nullptr;
340     if (asyncContext->status == napi_ok) {
341         napi_get_null(env, &errJs);
342         napi_get_null(env, &dataJs);
343     } else {
344         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
345         napi_get_null(env, &dataJs);
346     }
347     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
348     delete asyncContext;
349 }
350 
ParseParaSetOAName(napi_env env,napi_callback_info cbInfo,SetOANameAsyncContext * asyncContext)351 bool ParseParaSetOAName(napi_env env, napi_callback_info cbInfo, SetOANameAsyncContext *asyncContext)
352 {
353     size_t argc = ARGS_SIZE_THREE;
354     napi_value argv[ARGS_SIZE_THREE] = {0};
355     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
356 
357     if (argc == ARGS_SIZE_THREE) {
358         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
359             ACCOUNT_LOGE("Get SetOAName callbackRef failed");
360             std::string errMsg = "The type of arg " + std::to_string(argc) + " must be function";
361             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
362             return false;
363         }
364     }
365 
366     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
367         ACCOUNT_LOGE("Get id failed");
368         std::string errMsg = "The type of arg 1 must be number";
369         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
370         return false;
371     }
372     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->name)) {
373         ACCOUNT_LOGE("Get name failed");
374         std::string errMsg = "The type of arg 2 must be string";
375         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
376         return false;
377     }
378 
379     return true;
380 }
381 
SetOANameExecuteCB(napi_env env,void * data)382 void SetOANameExecuteCB(napi_env env, void *data)
383 {
384     SetOANameAsyncContext *asyncContext = reinterpret_cast<SetOANameAsyncContext *>(data);
385     asyncContext->errCode = OsAccountManager::SetOsAccountName(asyncContext->id, asyncContext->name);
386     ACCOUNT_LOGD("errcode is %{public}d", asyncContext->errCode);
387     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
388 }
389 
SetOANameCallbackCompletedCB(napi_env env,napi_status status,void * data)390 void SetOANameCallbackCompletedCB(napi_env env, napi_status status, void *data)
391 {
392     ACCOUNT_LOGD("napi_create_async_work complete");
393     SetOANameAsyncContext *asyncContext = reinterpret_cast<SetOANameAsyncContext *>(data);
394     napi_value errJs = nullptr;
395     napi_value dataJs = nullptr;
396     if (asyncContext->status == napi_ok) {
397         napi_get_null(env, &errJs);
398         napi_get_null(env, &dataJs);
399     } else {
400         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
401         napi_get_null(env, &dataJs);
402     }
403     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
404     delete asyncContext;
405 }
406 
ParseParaSetOAConstraints(napi_env env,napi_callback_info cbInfo,SetOAConsAsyncContext * asyncContext)407 bool ParseParaSetOAConstraints(napi_env env, napi_callback_info cbInfo, SetOAConsAsyncContext *asyncContext)
408 {
409     size_t argc = ARGS_SIZE_FOUR;
410     napi_value argv[ARGS_SIZE_FOUR] = {0};
411     NAPI_CALL_BASE(env, napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr), false);
412 
413     // argv[3] : callback
414     if (argc == ARGS_SIZE_FOUR) {
415         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
416             ACCOUNT_LOGE("Get callbackRef failed");
417             std::string errMsg = "The type of arg " + std::to_string(argc) + " must be function";
418             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
419             return false;
420         }
421     }
422 
423     // argv[0] : localId
424     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
425         ACCOUNT_LOGE("Get id failed");
426         std::string errMsg = "The type of arg 1 must be number";
427         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
428         return false;
429     }
430 
431     // argv[1] : Array<string>
432     if (!GetStringArrayProperty(env, argv[PARAMONE], asyncContext->constraints, false)) {
433         ACCOUNT_LOGE("Get constraints failed, expected array of strings");
434         std::string errMsg = "The type of arg 2 must be unempty array of strings";
435         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, true);
436         return false;
437     }
438 
439     // argv[2] : enable
440     if (!GetBoolProperty(env, argv[PARAMTWO], asyncContext->enable)) {
441         ACCOUNT_LOGE("Get enable failed");
442         std::string errMsg = "The type of arg 3 must be boolean";
443         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, true);
444         return false;
445     }
446 
447     return true;
448 }
449 
SetOAConsExecuteCB(napi_env env,void * data)450 void SetOAConsExecuteCB(napi_env env, void *data)
451 {
452     SetOAConsAsyncContext *asyncContext = reinterpret_cast<SetOAConsAsyncContext *>(data);
453     asyncContext->errCode =
454         OsAccountManager::SetOsAccountConstraints(asyncContext->id, asyncContext->constraints, asyncContext->enable);
455     ACCOUNT_LOGD("errcode is %{public}d", asyncContext->errCode);
456     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
457 }
458 
SetOAConsCallbackCompletedCB(napi_env env,napi_status status,void * data)459 void SetOAConsCallbackCompletedCB(napi_env env, napi_status status, void *data)
460 {
461     ACCOUNT_LOGD("napi_create_async_work complete");
462     SetOAConsAsyncContext *asyncContext = reinterpret_cast<SetOAConsAsyncContext *>(data);
463     napi_value errJs = nullptr;
464     napi_value dataJs = nullptr;
465     if (asyncContext->status == napi_ok) {
466         napi_get_null(env, &errJs);
467         napi_get_null(env, &dataJs);
468     } else {
469         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
470         napi_get_null(env, &dataJs);
471     }
472     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
473     delete asyncContext;
474 }
475 
ParseParaActiveOA(napi_env env,napi_callback_info cbInfo,ActivateOAAsyncContext * asyncContext)476 bool ParseParaActiveOA(napi_env env, napi_callback_info cbInfo, ActivateOAAsyncContext *asyncContext)
477 {
478     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
479 }
480 
ActivateOAExecuteCB(napi_env env,void * data)481 void ActivateOAExecuteCB(napi_env env, void *data)
482 {
483     ActivateOAAsyncContext *activateOACB = reinterpret_cast<ActivateOAAsyncContext *>(data);
484     activateOACB->errCode = OsAccountManager::ActivateOsAccount(activateOACB->id);
485     ACCOUNT_LOGD("errcode is %{public}d", activateOACB->errCode);
486     activateOACB->status = (activateOACB->errCode == 0) ? napi_ok : napi_generic_failure;
487 }
488 
ActivateOACallbackCompletedCB(napi_env env,napi_status status,void * data)489 void ActivateOACallbackCompletedCB(napi_env env, napi_status status, void *data)
490 {
491     ACCOUNT_LOGD("napi_create_async_work complete");
492     ActivateOAAsyncContext *asyncContext = reinterpret_cast<ActivateOAAsyncContext *>(data);
493     napi_value errJs = nullptr;
494     napi_value dataJs = nullptr;
495     if (asyncContext->status == napi_ok) {
496         napi_get_null(env, &errJs);
497         napi_get_null(env, &dataJs);
498     } else {
499         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
500         napi_get_null(env, &dataJs);
501     }
502     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
503     delete asyncContext;
504 }
505 
ParseParaCreateOA(napi_env env,napi_callback_info cbInfo,CreateOAAsyncContext * asyncContext)506 bool ParseParaCreateOA(napi_env env, napi_callback_info cbInfo, CreateOAAsyncContext *asyncContext)
507 {
508     size_t argc = ARGS_SIZE_THREE;
509     napi_value argv[ARGS_SIZE_THREE] = {0};
510     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
511     if (argc == ARGS_SIZE_THREE) {
512         if (!GetCallbackProperty(env, argv[PARAMTWO], asyncContext->callbackRef, 1)) {
513             napi_has_named_property(env, argv[PARAMTWO], "shortName", &asyncContext->hasShortName);
514             if (asyncContext->hasShortName &&
515                 !GetStringPropertyByKey(env, argv[PARAMTWO], "shortName", asyncContext->shortName)) {
516                 ACCOUNT_LOGE("get CreateOsAccountOptions's shortName failed");
517                 std::string errMsg = "Parameter error. The type of arg 3 must be function or CreateOsAccountOptions";
518                 AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
519                 return false;
520             }
521             GetStringArrayPropertyByKey(env, argv[PARAMTWO], "disallowedBundleNames",
522                 asyncContext->disallowedHapList, true);
523         }
524     }
525 
526     if (!GetStringProperty(env, argv[PARAMZERO], asyncContext->name)) {
527         ACCOUNT_LOGE("Get name failed");
528         std::string errMsg = "Parameter error. The type of \"localName\" must be string";
529         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
530         return false;
531     }
532 
533     int32_t type = 0;
534     if (!GetIntProperty(env, argv[PARAMONE], type)) {
535         ACCOUNT_LOGE("Get type failed");
536         std::string errMsg = "Parameter error. The type of \"type\" must be OsAccountType";
537         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
538         return false;
539     }
540 
541     asyncContext->type = static_cast<OsAccountType>(type);
542     return true;
543 }
544 
ParseDomainAccountInfo(napi_env env,napi_value object,DomainAccountInfo & info)545 static bool ParseDomainAccountInfo(napi_env env, napi_value object, DomainAccountInfo &info)
546 {
547     if (!GetStringPropertyByKey(env, object, "domain", info.domain_)) {
548         ACCOUNT_LOGE("get domainInfo's domain failed");
549         return false;
550     }
551     if (!GetStringPropertyByKey(env, object, "accountName", info.accountName_)) {
552         ACCOUNT_LOGE("get domainInfo's accountName failed");
553         return false;
554     }
555     bool hasProp = false;
556     napi_has_named_property(env, object, "accountId", &hasProp);
557     if (hasProp) {
558         napi_value value = nullptr;
559         napi_get_named_property(env, object, "accountId", &value);
560         napi_valuetype valueType = napi_undefined;
561         napi_typeof(env, value, &valueType);
562         if ((valueType == napi_undefined) || (valueType == napi_null)) {
563             ACCOUNT_LOGI("the accountId is undefined or null");
564         } else {
565             if (!GetStringProperty(env, value, info.accountId_)) {
566                 ACCOUNT_LOGE("get domainInfo's accountId failed");
567                 return false;
568             }
569         }
570     }
571     if (!GetOptionalStringPropertyByKey(env, object, "serverConfigId", info.serverConfigId_)) {
572         ACCOUNT_LOGE("Get domainInfo's serverConfigId failed");
573         return false;
574     }
575     return true;
576 }
577 
ParseDomainOptionInfo(napi_env env,napi_value object,CreateOsAccountForDomainOptions & domainOptions)578 static bool ParseDomainOptionInfo(napi_env env, napi_value object, CreateOsAccountForDomainOptions &domainOptions)
579 {
580     if (!GetStringPropertyByKey(env, object, "shortName", domainOptions.shortName)) {
581         ACCOUNT_LOGE("Failed to get options's shortName");
582         return false;
583     }
584     domainOptions.hasShortName = true;
585     return true;
586 }
587 
ParseParaCreateOAForDomain(napi_env env,napi_callback_info cbInfo,CreateOAForDomainAsyncContext * asyncContext)588 bool ParseParaCreateOAForDomain(napi_env env, napi_callback_info cbInfo,
589     CreateOAForDomainAsyncContext *asyncContext)
590 {
591     size_t argc = ARGS_SIZE_THREE;
592     napi_value argv[ARGS_SIZE_THREE] = {0};
593     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
594 
595     napi_valuetype valueType = napi_undefined;
596     if (argc == ARGS_SIZE_THREE) {
597         napi_typeof(env, argv[ARGS_SIZE_TWO], &valueType);
598         if (!GetCallbackProperty(env, argv[PARAMTWO], asyncContext->callbackRef, 1)) {
599             if (!ParseDomainOptionInfo(env, argv[PARAMTWO], asyncContext->domainOptions)) {
600                 ACCOUNT_LOGE("Failed to get domainOptions");
601                 std::string errMsg =
602                     "Parameter error. The type of arg 3 must be function or CreateOsAccountForDomainOptions";
603                 AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
604                 return false;
605             }
606         }
607     }
608 
609     int32_t id = 0;
610     if (!GetIntProperty(env, argv[PARAMZERO], id)) {
611         ACCOUNT_LOGE("Get type failed");
612         std::string errMsg = "Parameter error. The type of \"type\" must be OsAccountType";
613         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
614         return false;
615     }
616     asyncContext->type = static_cast<OsAccountType>(id);
617 
618     if (!ParseDomainAccountInfo(env, argv[PARAMONE], asyncContext->domainInfo)) {
619         ACCOUNT_LOGE("get domainInfo failed");
620         std::string errMsg = "Parameter error. The type of \"domainInfo\" must be DomainAccountInfo";
621         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
622         return false;
623     }
624     return true;
625 }
626 
CreateOAExecuteCB(napi_env env,void * data)627 void CreateOAExecuteCB(napi_env env, void *data)
628 {
629     ACCOUNT_LOGD("napi_create_async_work running");
630     CreateOAAsyncContext *asyncContext = reinterpret_cast<CreateOAAsyncContext *>(data);
631     CreateOsAccountOptions options;
632     options.shortName = asyncContext->shortName;
633     options.disallowedHapList = asyncContext->disallowedHapList;
634     options.hasShortName = asyncContext->hasShortName;
635     asyncContext->errCode = OsAccountManager::CreateOsAccount(asyncContext->name, asyncContext->shortName,
636         asyncContext->type, options, asyncContext->osAccountInfos);
637     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
638 }
639 
CreateOAForDomainCompletedCB(napi_env env,napi_status status,void * data)640 void CreateOAForDomainCompletedCB(napi_env env, napi_status status, void *data)
641 {
642     delete reinterpret_cast<CreateOAForDomainAsyncContext *>(data);
643 }
644 
CreateOAForDomainExecuteCB(napi_env env,void * data)645 void CreateOAForDomainExecuteCB(napi_env env, void *data)
646 {
647     CreateOAForDomainAsyncContext *asyncContext = reinterpret_cast<CreateOAForDomainAsyncContext *>(data);
648     auto callback = std::make_shared<NapiCreateDomainCallback>(env, asyncContext->callbackRef, asyncContext->deferred);
649     asyncContext->errCode =
650         OsAccountManager::CreateOsAccountForDomain(asyncContext->type, asyncContext->domainInfo,
651             callback, asyncContext->domainOptions);
652     if (asyncContext->errCode != ERR_OK) {
653         Parcel emptyParcel;
654         callback->OnResult(asyncContext->errCode, emptyParcel);
655     }
656     asyncContext->callbackRef = nullptr;
657     asyncContext->deferred = nullptr;
658 }
659 
CreateOACallbackCompletedCB(napi_env env,napi_status status,void * data)660 void CreateOACallbackCompletedCB(napi_env env, napi_status status, void *data)
661 {
662     ACCOUNT_LOGD("napi_create_async_work complete");
663     CreateOAAsyncContext *asyncContext = reinterpret_cast<CreateOAAsyncContext *>(data);
664     napi_value errJs = nullptr;
665     napi_value dataJs = nullptr;
666     if (asyncContext->status == napi_ok) {
667         napi_get_null(env, &errJs);
668         GetOACBInfoToJs(env, asyncContext->osAccountInfos, dataJs);
669     } else {
670         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
671         napi_get_null(env, &dataJs);
672     }
673     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
674     delete asyncContext;
675 }
676 
CreateOAForDomainCallbackCompletedWork(uv_work_t * work,int status)677 void CreateOAForDomainCallbackCompletedWork(uv_work_t *work, int status)
678 {
679     std::unique_ptr<uv_work_t> workPtr(work);
680     napi_handle_scope scope = nullptr;
681     if (!InitUvWorkCallbackEnv(work, scope)) {
682         return;
683     }
684     std::unique_ptr<CreateOAForDomainAsyncContext> asyncContext(
685         reinterpret_cast<CreateOAForDomainAsyncContext *>(work->data));
686     napi_value errJs = nullptr;
687     napi_value dataJs = nullptr;
688     if (asyncContext->errCode == ERR_OK) {
689         GetOACBInfoToJs(asyncContext->env, asyncContext->osAccountInfos, dataJs);
690     } else {
691         errJs = GenerateBusinessError(asyncContext->env, asyncContext->errCode);
692     }
693     ReturnCallbackOrPromise(asyncContext->env, asyncContext.get(), errJs, dataJs);
694     napi_close_handle_scope(asyncContext->env, scope);
695 }
696 
ParseParaGetOACount(napi_env env,napi_callback_info cbInfo,GetOACountAsyncContext * asyncContext)697 bool ParseParaGetOACount(napi_env env, napi_callback_info cbInfo, GetOACountAsyncContext *asyncContext)
698 {
699     return ParseOneParaContext(env, cbInfo, asyncContext);
700 }
701 
GetOACountExecuteCB(napi_env env,void * data)702 void GetOACountExecuteCB(napi_env env, void *data)
703 {
704     GetOACountAsyncContext *asyncContext = reinterpret_cast<GetOACountAsyncContext *>(data);
705     asyncContext->errCode = OsAccountManager::GetCreatedOsAccountsCount(asyncContext->osAccountsCount);
706     // for compatibility
707     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
708         asyncContext->errCode = ERR_OSACCOUNT_KIT_GET_CREATED_OS_ACCOUNT_COUNT_ERROR;
709     }
710     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
711 }
712 
GetOACountCallbackCompletedCB(napi_env env,napi_status status,void * data)713 void GetOACountCallbackCompletedCB(napi_env env, napi_status status, void *data)
714 {
715     ACCOUNT_LOGD("napi_create_async_work complete");
716     GetOACountAsyncContext *asyncContext = reinterpret_cast<GetOACountAsyncContext *>(data);
717     napi_value errJs = nullptr;
718     napi_value dataJs = nullptr;
719     if (asyncContext->status == napi_ok) {
720         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
721         napi_create_uint32(env, asyncContext->osAccountsCount, &dataJs);
722     } else {
723         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
724         if (asyncContext->throwErr) {
725             napi_get_null(env, &dataJs);
726         } else {
727             napi_create_uint32(env, asyncContext->osAccountsCount, &dataJs);
728         }
729     }
730     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
731     delete asyncContext;
732 }
733 
ParseParaDbDeviceId(napi_env env,napi_callback_info cbInfo,DbDeviceIdAsyncContext * asyncContext)734 bool ParseParaDbDeviceId(napi_env env, napi_callback_info cbInfo, DbDeviceIdAsyncContext *asyncContext)
735 {
736     return ParseOneParaContext(env, cbInfo, asyncContext);
737 }
738 
DbDeviceIdExecuteCB(napi_env env,void * data)739 void DbDeviceIdExecuteCB(napi_env env, void *data)
740 {
741     DbDeviceIdAsyncContext *asyncContext = reinterpret_cast<DbDeviceIdAsyncContext *>(data);
742     asyncContext->errCode = OsAccountManager::GetDistributedVirtualDeviceId(asyncContext->deviceId);
743     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
744     if (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED) {
745         uint32_t targetVersion = 0;
746         if (GetSelfTargetVersion(targetVersion) && (targetVersion < COMPATIBILITY_CHANGE_VERSION_API12)) {
747             asyncContext->errCode = ERR_OSACCOUNT_KIT_GET_DISTRIBUTED_VIRTUAL_DEVICE_ID_ERROR;
748         }
749     }
750     if (asyncContext->errCode != ERR_OK) {
751         ACCOUNT_LOGE("GetDistributedVirtualDeviceId err is %{public}d", asyncContext->errCode);
752     }
753 }
754 
DbDeviceIdCallbackCompletedCB(napi_env env,napi_status status,void * data)755 void DbDeviceIdCallbackCompletedCB(napi_env env, napi_status status, void *data)
756 {
757     ACCOUNT_LOGD("napi_create_async_work complete");
758     DbDeviceIdAsyncContext *asyncContext = reinterpret_cast<DbDeviceIdAsyncContext *>(data);
759     napi_value errJs = nullptr;
760     napi_value dataJs = nullptr;
761     if (asyncContext->status == napi_ok) {
762         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
763         napi_create_string_utf8(env, asyncContext->deviceId.c_str(), NAPI_AUTO_LENGTH, &dataJs);
764     } else {
765         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
766         if (asyncContext->throwErr) {
767             napi_get_null(env, &dataJs);
768         } else {
769             napi_create_string_utf8(env, asyncContext->deviceId.c_str(), NAPI_AUTO_LENGTH, &dataJs);
770         }
771     }
772     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
773     delete asyncContext;
774 }
775 
ParseParaGetAllCons(napi_env env,napi_callback_info cbInfo,GetAllConsAsyncContext * asyncContext)776 bool ParseParaGetAllCons(napi_env env, napi_callback_info cbInfo, GetAllConsAsyncContext *asyncContext)
777 {
778     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
779 }
780 
GetAllConsExecuteCB(napi_env env,void * data)781 void GetAllConsExecuteCB(napi_env env, void *data)
782 {
783     GetAllConsAsyncContext *asyncContext = reinterpret_cast<GetAllConsAsyncContext *>(data);
784     asyncContext->errCode = OsAccountManager::GetOsAccountAllConstraints(asyncContext->id, asyncContext->constraints);
785     // for compatibility
786     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
787         asyncContext->errCode = ERR_OSACCOUNT_KIT_GET_OS_ACCOUNT_ALL_CONSTRAINTS_ERROR;
788     }
789     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
790 }
791 
GetAllConsCallbackCompletedCB(napi_env env,napi_status status,void * data)792 void GetAllConsCallbackCompletedCB(napi_env env, napi_status status, void *data)
793 {
794     ACCOUNT_LOGD("napi_create_async_work complete");
795     GetAllConsAsyncContext *asyncContext = reinterpret_cast<GetAllConsAsyncContext *>(data);
796     napi_value errJs = nullptr;
797     napi_value dataJs = nullptr;
798     if (asyncContext->status == napi_ok) {
799         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
800         GetAllAccountCons(env, asyncContext->constraints, dataJs);
801     } else {
802         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
803         if (asyncContext->throwErr) {
804             napi_get_null(env, &dataJs);
805         } else {
806             GetAllAccountCons(env, asyncContext->constraints, dataJs);
807         }
808     }
809     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
810     delete asyncContext;
811 }
812 
GetAllAccountCons(napi_env env,const std::vector<std::string> & info,napi_value & result)813 void GetAllAccountCons(napi_env env, const std::vector<std::string> &info, napi_value &result)
814 {
815     napi_create_array(env, &result);
816     uint32_t index = 0;
817 
818     for (auto item : info) {
819         napi_value consStr = nullptr;
820         napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &consStr);
821         napi_set_element(env, result, index, consStr);
822         index++;
823     }
824 }
825 
GetActiveIds(napi_env env,const std::vector<int> & ids,napi_value & result)826 void GetActiveIds(napi_env env, const std::vector<int> &ids, napi_value &result)
827 {
828     napi_create_array(env, &result);
829     uint32_t index = 0;
830 
831     for (auto id : ids) {
832         napi_value tempID = nullptr;
833         napi_create_int32(env, id, &tempID);
834         napi_set_element(env, result, index, tempID);
835         index++;
836     }
837 }
838 
ParseParaProcessId(napi_env env,napi_callback_info cbInfo,GetIdAsyncContext * asyncContext)839 bool ParseParaProcessId(napi_env env, napi_callback_info cbInfo, GetIdAsyncContext *asyncContext)
840 {
841     return ParseOneParaContext(env, cbInfo, asyncContext);
842 }
843 
GetProcessIdExecuteCB(napi_env env,void * data)844 void GetProcessIdExecuteCB(napi_env env, void *data)
845 {
846     GetIdAsyncContext *asyncContext = reinterpret_cast<GetIdAsyncContext *>(data);
847     asyncContext->errCode = OsAccountManager::GetOsAccountLocalIdFromProcess(asyncContext->id);
848     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
849     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
850 }
851 
GetProcessIdCallbackCompletedCB(napi_env env,napi_status status,void * data)852 void GetProcessIdCallbackCompletedCB(napi_env env, napi_status status, void *data)
853 {
854     ACCOUNT_LOGD("napi_create_async_work complete");
855     GetIdAsyncContext *asyncContext = reinterpret_cast<GetIdAsyncContext *>(data);
856     napi_value errJs = nullptr;
857     napi_value dataJs = nullptr;
858     if (asyncContext->status == napi_ok) {
859         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
860         napi_create_int32(env, asyncContext->id, &dataJs);
861     } else {
862         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
863         if (asyncContext->throwErr) {
864             napi_get_null(env, &dataJs);
865         } else {
866             napi_create_int32(env, asyncContext->id, &dataJs);
867         }
868     }
869     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
870     delete asyncContext;
871 }
872 
ParseQueryAllCreateOA(napi_env env,napi_callback_info cbInfo,QueryCreateOAAsyncContext * asyncContext)873 bool ParseQueryAllCreateOA(napi_env env, napi_callback_info cbInfo, QueryCreateOAAsyncContext *asyncContext)
874 {
875     return ParseOneParaContext(env, cbInfo, asyncContext);
876 }
877 
ParseQueryOAConstraintSrcTypes(napi_env env,napi_callback_info cbInfo,QueryOAConstraintSrcTypeContext * asyncContext)878 bool ParseQueryOAConstraintSrcTypes(napi_env env, napi_callback_info cbInfo,
879     QueryOAConstraintSrcTypeContext *asyncContext)
880 {
881     size_t argc = ARGS_SIZE_THREE;
882     napi_value argv[ARGS_SIZE_THREE] = {0};
883     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
884     if (argc == ARGS_SIZE_THREE) {
885         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
886             ACCOUNT_LOGE("Get callbackRef failed");
887             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
888             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
889             return false;
890         }
891     }
892 
893     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
894         ACCOUNT_LOGE("Get id failed");
895         std::string errMsg = "Parameter error. The type of \"localId\" must be number";
896         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
897         return false;
898     }
899     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->constraint)) {
900         ACCOUNT_LOGE("Get constraint failed");
901         std::string errMsg = "Parameter error. The type of \"constraint\" must be string";
902         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
903         return false;
904     }
905 
906     return true;
907 }
908 
QueryOAContSrcTypeExecuteCB(napi_env env,void * data)909 void QueryOAContSrcTypeExecuteCB(napi_env env, void *data)
910 {
911     QueryOAConstraintSrcTypeContext *asyncContext = reinterpret_cast<QueryOAConstraintSrcTypeContext *>(data);
912     asyncContext->errCode = OsAccountManager::QueryOsAccountConstraintSourceTypes(asyncContext->id,
913         asyncContext->constraint, asyncContext->constraintSourceTypeInfos);
914     ACCOUNT_LOGI("errocde is %{public}d", asyncContext->errCode);
915     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
916 }
917 
QueryOAContSrcTypeCallbackCompletedCB(napi_env env,napi_status status,void * data)918 void QueryOAContSrcTypeCallbackCompletedCB(napi_env env, napi_status status, void *data)
919 {
920     ACCOUNT_LOGI("napi_create_async_work complete");
921     QueryOAConstraintSrcTypeContext *asyncContext = reinterpret_cast<QueryOAConstraintSrcTypeContext *>(data);
922     napi_value errJs = nullptr;
923     napi_value dataJs = nullptr;
924     if (asyncContext->status == napi_ok) {
925         napi_get_null(env, &errJs);
926         QueryOAContSrcTypeForResult(env, asyncContext->constraintSourceTypeInfos, dataJs);
927     } else {
928         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
929         napi_get_null(env, &dataJs);
930     }
931     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
932     delete asyncContext;
933 }
934 
QueryOAContSrcTypeForResult(napi_env env,const std::vector<ConstraintSourceTypeInfo> & infos,napi_value & result)935 void QueryOAContSrcTypeForResult(napi_env env, const std::vector<ConstraintSourceTypeInfo> &infos, napi_value &result)
936 {
937     napi_create_array(env, &result);
938     uint32_t index = 0;
939 
940     for (auto item : infos) {
941         napi_value objTypeInfo = nullptr;
942         napi_create_object(env, &objTypeInfo);
943 
944         napi_value srcLocalId = nullptr;
945         napi_create_int32(env, item.localId, &srcLocalId);
946         napi_set_named_property(env, objTypeInfo, "localId", srcLocalId);
947 
948         napi_value valToJs = nullptr;
949         napi_create_int32(env, item.typeInfo, &valToJs);
950 
951         napi_set_named_property(env, objTypeInfo, "type", valToJs);
952         napi_set_element(env, result, index, objTypeInfo);
953         index++;
954     }
955 }
956 
ParseQueryActiveIds(napi_env env,napi_callback_info cbInfo,QueryActiveIdsAsyncContext * asyncContext)957 bool ParseQueryActiveIds(napi_env env, napi_callback_info cbInfo, QueryActiveIdsAsyncContext *asyncContext)
958 {
959     return ParseOneParaContext(env, cbInfo, asyncContext);
960 }
961 
QueryCreateOAExecuteCB(napi_env env,void * data)962 void QueryCreateOAExecuteCB(napi_env env, void *data)
963 {
964     QueryCreateOAAsyncContext *asyncContext = reinterpret_cast<QueryCreateOAAsyncContext *>(data);
965     asyncContext->errCode = OsAccountManager::QueryAllCreatedOsAccounts(asyncContext->osAccountInfos);
966     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
967     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
968 }
969 
QueryActiveIdsExecuteCB(napi_env env,void * data)970 void QueryActiveIdsExecuteCB(napi_env env, void *data)
971 {
972     QueryActiveIdsAsyncContext *asyncContext = reinterpret_cast<QueryActiveIdsAsyncContext *>(data);
973     asyncContext->errCode = OsAccountManager::QueryActiveOsAccountIds(asyncContext->osAccountIds);
974     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
975     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
976 }
977 
QueryCreateOACallbackCompletedCB(napi_env env,napi_status status,void * data)978 void QueryCreateOACallbackCompletedCB(napi_env env, napi_status status, void *data)
979 {
980     ACCOUNT_LOGD("napi_create_async_work complete");
981     QueryCreateOAAsyncContext *asyncContext = reinterpret_cast<QueryCreateOAAsyncContext *>(data);
982     napi_value errJs = nullptr;
983     napi_value dataJs = nullptr;
984     if (asyncContext->status == napi_ok) {
985         napi_get_null(env, &errJs);
986         QueryOAInfoForResult(env, asyncContext->osAccountInfos, dataJs);
987     } else {
988         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
989         napi_get_null(env, &dataJs);
990     }
991     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
992     delete asyncContext;
993 }
994 
GetForegroundOALocalIdExecuteCB(napi_env env,void * data)995 void GetForegroundOALocalIdExecuteCB(napi_env env, void *data)
996 {
997     GetForegroundOALocalIdAsyncContext *asyncContext = reinterpret_cast<GetForegroundOALocalIdAsyncContext *>(data);
998     asyncContext->errCode = OsAccountManager::GetForegroundOsAccountLocalId(asyncContext->id);
999 }
1000 
GetForegroundOALocalIdCallbackCompletedCB(napi_env env,napi_status status,void * data)1001 void GetForegroundOALocalIdCallbackCompletedCB(napi_env env, napi_status status, void *data)
1002 {
1003     GetForegroundOALocalIdAsyncContext *asyncContext = reinterpret_cast<GetForegroundOALocalIdAsyncContext *>(data);
1004     std::unique_ptr<GetForegroundOALocalIdAsyncContext> asyncContextPtr{asyncContext};
1005     napi_value errJs = nullptr;
1006     napi_value dataJs = nullptr;
1007     if (asyncContext->errCode == ERR_OK) {
1008         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &errJs));
1009         NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->id, &dataJs));
1010     } else {
1011         errJs = GenerateBusinessError(env, asyncContext->errCode);
1012         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &dataJs));
1013     }
1014     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1015 }
1016 
QueryActiveIdsCallbackCompletedCB(napi_env env,napi_status status,void * data)1017 void QueryActiveIdsCallbackCompletedCB(napi_env env, napi_status status, void *data)
1018 {
1019     ACCOUNT_LOGD("napi_create_async_work complete");
1020     QueryActiveIdsAsyncContext *asyncContext = reinterpret_cast<QueryActiveIdsAsyncContext *>(data);
1021     napi_value errJs = nullptr;
1022     napi_value dataJs = nullptr;
1023     if (asyncContext->status == napi_ok) {
1024         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1025         GetActiveIds(env, asyncContext->osAccountIds, dataJs);
1026     } else {
1027         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1028         if (asyncContext->throwErr) {
1029             napi_get_null(env, &dataJs);
1030         } else {
1031             GetActiveIds(env, asyncContext->osAccountIds, dataJs);
1032         }
1033     }
1034     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1035     delete asyncContext;
1036 }
1037 
QueryOAInfoForResult(napi_env env,const std::vector<OsAccountInfo> & info,napi_value & result)1038 void QueryOAInfoForResult(napi_env env, const std::vector<OsAccountInfo> &info, napi_value &result)
1039 {
1040     napi_create_array(env, &result);
1041     uint32_t index = 0;
1042 
1043     for (auto item : info) {
1044         napi_value objOAInfo = nullptr;
1045         napi_create_object(env, &objOAInfo);
1046         GetOACBInfoToJs(env, item, objOAInfo);
1047         napi_set_element(env, result, index, objOAInfo);
1048         index++;
1049     }
1050 }
1051 
ParseParaGetPhoto(napi_env env,napi_callback_info cbInfo,GetOAPhotoAsyncContext * asyncContext)1052 bool ParseParaGetPhoto(napi_env env, napi_callback_info cbInfo, GetOAPhotoAsyncContext *asyncContext)
1053 {
1054     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
1055 }
1056 
GetOsAccountNameExecuteCB(napi_env env,void * data)1057 void GetOsAccountNameExecuteCB(napi_env env, void *data)
1058 {
1059     ACCOUNT_LOGD("Running napi_create_async_work");
1060     GetOsAccountNameContext *asyncContext = reinterpret_cast<GetOsAccountNameContext *>(data);
1061     asyncContext->errCode = OsAccountManager::GetOsAccountName(asyncContext->name);
1062 }
1063 
GetOsAccountNameCallbackCompletedCB(napi_env env,napi_status status,void * data)1064 void GetOsAccountNameCallbackCompletedCB(napi_env env, napi_status status, void *data)
1065 {
1066     ACCOUNT_LOGD("Complete napi_create_async_work");
1067     GetOsAccountNameContext *asyncContext = reinterpret_cast<GetOsAccountNameContext *>(data);
1068     napi_value errJs = nullptr;
1069     napi_value dataJs = nullptr;
1070     if (asyncContext->errCode == napi_ok) {
1071         napi_get_null(env, &errJs);
1072         napi_create_string_utf8(env, asyncContext->name.c_str(), NAPI_AUTO_LENGTH, &dataJs);
1073     } else {
1074         errJs = GenerateBusinessError(env, asyncContext->errCode);
1075         napi_get_null(env, &dataJs);
1076     }
1077     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1078     delete asyncContext;
1079 }
1080 
GetOAPhotoExecuteCB(napi_env env,void * data)1081 void GetOAPhotoExecuteCB(napi_env env, void *data)
1082 {
1083     ACCOUNT_LOGD("napi_create_async_work running");
1084     GetOAPhotoAsyncContext *asyncContext = reinterpret_cast<GetOAPhotoAsyncContext *>(data);
1085     asyncContext->errCode = OsAccountManager::GetOsAccountProfilePhoto(asyncContext->id, asyncContext->photo);
1086     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1087 }
1088 
GetOAPhotoCallbackCompletedCB(napi_env env,napi_status status,void * data)1089 void GetOAPhotoCallbackCompletedCB(napi_env env, napi_status status, void *data)
1090 {
1091     ACCOUNT_LOGD("napi_create_async_work complete");
1092     GetOAPhotoAsyncContext *asyncContext = reinterpret_cast<GetOAPhotoAsyncContext *>(data);
1093     napi_value errJs = nullptr;
1094     napi_value dataJs = nullptr;
1095     if (asyncContext->status == napi_ok) {
1096         napi_get_null(env, &errJs);
1097         napi_create_string_utf8(env, asyncContext->photo.c_str(), NAPI_AUTO_LENGTH, &dataJs);
1098     } else {
1099         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1100         napi_get_null(env, &dataJs);
1101     }
1102     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1103     delete asyncContext;
1104 }
1105 
ParseParaCurrentOA(napi_env env,napi_callback_info cbInfo,CurrentOAAsyncContext * asyncContext)1106 bool ParseParaCurrentOA(napi_env env, napi_callback_info cbInfo, CurrentOAAsyncContext *asyncContext)
1107 {
1108     return ParseOneParaContext(env, cbInfo, asyncContext);
1109 }
1110 
QueryCurrentOAExecuteCB(napi_env env,void * data)1111 void QueryCurrentOAExecuteCB(napi_env env, void *data)
1112 {
1113     CurrentOAAsyncContext *asyncContext = reinterpret_cast<CurrentOAAsyncContext *>(data);
1114     asyncContext->errCode = OsAccountManager::QueryCurrentOsAccount(asyncContext->osAccountInfos);
1115     // for compatibility
1116     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
1117         asyncContext->errCode = ERR_OSACCOUNT_KIT_QUERY_CURRENT_OS_ACCOUNT_ERROR;
1118     }
1119     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1120 }
1121 
QueryCurrentOACallbackCompletedCB(napi_env env,napi_status status,void * data)1122 void QueryCurrentOACallbackCompletedCB(napi_env env, napi_status status, void *data)
1123 {
1124     CurrentOAAsyncContext *asyncContext = reinterpret_cast<CurrentOAAsyncContext *>(data);
1125     napi_value errJs = nullptr;
1126     napi_value dataJs = nullptr;
1127     if (asyncContext->status == napi_ok) {
1128         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1129         GetOACBInfoToJs(env, asyncContext->osAccountInfos, dataJs);
1130     } else {
1131         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1132         if (asyncContext->throwErr) {
1133             napi_get_null(env, &dataJs);
1134         } else {
1135             GetOACBInfoToJs(env, asyncContext->osAccountInfos, dataJs);
1136         }
1137     }
1138     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1139     delete asyncContext;
1140 }
1141 
ParseParaGetIdByUid(napi_env env,napi_callback_info cbInfo,GetIdByUidAsyncContext * asyncContext)1142 bool ParseParaGetIdByUid(napi_env env, napi_callback_info cbInfo, GetIdByUidAsyncContext *asyncContext)
1143 {
1144     size_t argc = ARGS_SIZE_TWO;
1145     napi_value argv[ARGS_SIZE_TWO] = {0};
1146     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1147     if (argc == ARGS_SIZE_TWO) {
1148         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1149             ACCOUNT_LOGE("Get callbackRef failed");
1150             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1151             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1152             return false;
1153         }
1154     }
1155 
1156     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->uid)) {
1157         ACCOUNT_LOGE("Get uid failed");
1158         std::string errMsg = "Parameter error. The type of \"uid\" must be number";
1159         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1160         return false;
1161     }
1162     return true;
1163 }
1164 
ParseParaGetIdByDomain(napi_env env,napi_callback_info cbInfo,GetIdByDomainAsyncContext * asyncContext)1165 bool ParseParaGetIdByDomain(napi_env env, napi_callback_info cbInfo, GetIdByDomainAsyncContext *asyncContext)
1166 {
1167     size_t argc = ARGS_SIZE_TWO;
1168     napi_value argv[ARGS_SIZE_TWO] = {0};
1169     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1170     if (argc == ARGS_SIZE_TWO) {
1171         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1172             ACCOUNT_LOGE("Get callbackRef failed");
1173             std::string errMsg = "The type of arg " + std::to_string(argc) + " must be function";
1174             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1175             return false;
1176         }
1177     }
1178 
1179     if (!ParseDomainAccountInfo(env, argv[PARAMZERO], asyncContext->domainInfo)) {
1180         ACCOUNT_LOGE("get domainInfo failed");
1181         std::string errMsg = "DomainInfo parse failed";
1182         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1183         return false;
1184     }
1185     return true;
1186 }
1187 
GetIdByUidExecuteCB(napi_env env,void * data)1188 void GetIdByUidExecuteCB(napi_env env, void *data)
1189 {
1190     GetIdByUidAsyncContext *asyncContext = reinterpret_cast<GetIdByUidAsyncContext *>(data);
1191     asyncContext->errCode = OsAccountManager::GetOsAccountLocalIdFromUid(asyncContext->uid, asyncContext->id);
1192     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1193     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1194 }
1195 
GetBundleIdByUidExecuteCB(napi_env env,void * data)1196 void GetBundleIdByUidExecuteCB(napi_env env, void *data)
1197 {
1198     GetIdByUidAsyncContext *asyncContext = reinterpret_cast<GetIdByUidAsyncContext *>(data);
1199     asyncContext->errCode = OsAccountManager::GetBundleIdFromUid(asyncContext->uid, asyncContext->id);
1200     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1201     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1202 }
1203 
GetIdByDomainExecuteCB(napi_env env,void * data)1204 void GetIdByDomainExecuteCB(napi_env env, void *data)
1205 {
1206     GetIdByDomainAsyncContext *asyncContext = reinterpret_cast<GetIdByDomainAsyncContext *>(data);
1207     asyncContext->errCode = OsAccountManager::GetOsAccountLocalIdFromDomain(
1208         asyncContext->domainInfo, asyncContext->id);
1209     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1210     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1211 }
1212 
GetIdByUidCallbackCompletedCB(napi_env env,napi_status status,void * data)1213 void GetIdByUidCallbackCompletedCB(napi_env env, napi_status status, void *data)
1214 {
1215     ACCOUNT_LOGD("napi_create_async_work complete");
1216     GetIdByUidAsyncContext *asyncContext = reinterpret_cast<GetIdByUidAsyncContext *>(data);
1217     napi_value errJs = nullptr;
1218     napi_value dataJs = nullptr;
1219     if (asyncContext->status == napi_ok) {
1220         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1221         napi_create_int32(env, asyncContext->id, &dataJs);
1222     } else {
1223         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1224         if (asyncContext->throwErr) {
1225             napi_get_null(env, &dataJs);
1226         } else {
1227             napi_create_int32(env, asyncContext->id, &dataJs);
1228         }
1229     }
1230     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1231     delete asyncContext;
1232 }
1233 
GetBundleIdByUidCallbackCompletedCB(napi_env env,napi_status status,void * data)1234 void GetBundleIdByUidCallbackCompletedCB(napi_env env, napi_status status, void *data)
1235 {
1236     ACCOUNT_LOGD("napi_create_async_work complete");
1237     GetIdByUidAsyncContext *asyncContext = reinterpret_cast<GetIdByUidAsyncContext *>(data);
1238     napi_value errJs = nullptr;
1239     napi_value dataJs = nullptr;
1240     if (asyncContext->status == napi_ok) {
1241         napi_get_null(env, &errJs);
1242         napi_create_int32(env, asyncContext->id, &dataJs);
1243     } else {
1244         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1245         napi_get_null(env, &dataJs);
1246     }
1247     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1248     delete asyncContext;
1249 }
1250 
GetIdByDomainCallbackCompletedCB(napi_env env,napi_status status,void * data)1251 void GetIdByDomainCallbackCompletedCB(napi_env env, napi_status status, void *data)
1252 {
1253     ACCOUNT_LOGD("napi_create_async_work complete");
1254     GetIdByDomainAsyncContext *asyncContext = reinterpret_cast<GetIdByDomainAsyncContext *>(data);
1255     napi_value errJs = nullptr;
1256     napi_value dataJs = nullptr;
1257     if (asyncContext->status == napi_ok) {
1258         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1259         napi_create_int32(env, asyncContext->id, &dataJs);
1260     } else {
1261         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1262         if (asyncContext->throwErr) {
1263             napi_get_null(env, &dataJs);
1264         } else {
1265             napi_create_int32(env, asyncContext->id, &dataJs);
1266         }
1267     }
1268     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1269     delete asyncContext;
1270 }
1271 
ParseParaSetPhoto(napi_env env,napi_callback_info cbInfo,SetOAPhotoAsyncContext * asyncContext)1272 bool ParseParaSetPhoto(napi_env env, napi_callback_info cbInfo, SetOAPhotoAsyncContext *asyncContext)
1273 {
1274     size_t argc = ARGS_SIZE_THREE;
1275     napi_value argv[ARGS_SIZE_THREE] = {0};
1276     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1277     if (argc == ARGS_SIZE_THREE) {
1278         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1279             ACCOUNT_LOGE("Get callbackRef failed");
1280             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1281             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1282             return false;
1283         }
1284     }
1285 
1286     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
1287         ACCOUNT_LOGE("Get id failed");
1288         std::string errMsg = "Parameter error. The type of \"localId\" must be number";
1289         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1290         return false;
1291     }
1292     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->photo)) {
1293         ACCOUNT_LOGE("Get photo failed");
1294         std::string errMsg = "Parameter error. The type of \"photo\" must be string";
1295         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1296         return false;
1297     }
1298 
1299     return true;
1300 }
1301 
SetPhotoExecuteCB(napi_env env,void * data)1302 void SetPhotoExecuteCB(napi_env env, void *data)
1303 {
1304     SetOAPhotoAsyncContext *asyncContext = reinterpret_cast<SetOAPhotoAsyncContext *>(data);
1305     asyncContext->errCode = OsAccountManager::SetOsAccountProfilePhoto(asyncContext->id, asyncContext->photo);
1306     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1307     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1308 }
1309 
SetPhotoCompletedCB(napi_env env,napi_status status,void * data)1310 void SetPhotoCompletedCB(napi_env env, napi_status status, void *data)
1311 {
1312     ACCOUNT_LOGD("napi_create_async_work complete");
1313     SetOAPhotoAsyncContext *asyncContext = reinterpret_cast<SetOAPhotoAsyncContext *>(data);
1314     napi_value errJs = nullptr;
1315     napi_value dataJs = nullptr;
1316     if (asyncContext->status == napi_ok) {
1317         napi_get_null(env, &errJs);
1318         napi_get_null(env, &dataJs);
1319     } else {
1320         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1321         napi_get_null(env, &dataJs);
1322     }
1323     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1324     delete asyncContext;
1325 }
1326 
ParseParaQueryMaxNum(napi_env env,napi_callback_info cbInfo,QueryMaxNumAsyncContext * asyncContext)1327 bool ParseParaQueryMaxNum(napi_env env, napi_callback_info cbInfo, QueryMaxNumAsyncContext *asyncContext)
1328 {
1329     return ParseOneParaContext(env, cbInfo, asyncContext);
1330 }
1331 
QueryMaxNumExecuteCB(napi_env env,void * data)1332 void QueryMaxNumExecuteCB(napi_env env, void *data)
1333 {
1334     QueryMaxNumAsyncContext *asyncContext = reinterpret_cast<QueryMaxNumAsyncContext *>(data);
1335     asyncContext->errCode = OsAccountManager::QueryMaxOsAccountNumber(asyncContext->maxOsAccountNumber);
1336     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1337     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1338 }
1339 
QueryMaxNumCompletedCB(napi_env env,napi_status status,void * data)1340 void QueryMaxNumCompletedCB(napi_env env, napi_status status, void *data)
1341 {
1342     ACCOUNT_LOGD("napi_create_async_work complete");
1343     QueryMaxNumAsyncContext *asyncContext = reinterpret_cast<QueryMaxNumAsyncContext *>(data);
1344     napi_value errJs = nullptr;
1345     napi_value dataJs = nullptr;
1346     if (asyncContext->status == napi_ok) {
1347         napi_get_null(env, &errJs);
1348         napi_create_uint32(env, asyncContext->maxOsAccountNumber, &dataJs);
1349     } else {
1350         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1351         napi_get_null(env, &dataJs);
1352     }
1353     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1354     delete asyncContext;
1355 }
1356 
ParseParaIsActived(napi_env env,napi_callback_info cbInfo,IsActivedAsyncContext * asyncContext)1357 bool ParseParaIsActived(napi_env env, napi_callback_info cbInfo, IsActivedAsyncContext *asyncContext)
1358 {
1359     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
1360 }
1361 
IsActivedExecuteCB(napi_env env,void * data)1362 void IsActivedExecuteCB(napi_env env, void *data)
1363 {
1364     IsActivedAsyncContext *asyncContext = reinterpret_cast<IsActivedAsyncContext *>(data);
1365     asyncContext->errCode = OsAccountManager::IsOsAccountActived(asyncContext->id, asyncContext->isOsAccountActived);
1366     // for compatibility
1367     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
1368         asyncContext->errCode = ERR_OSACCOUNT_KIT_IS_OS_ACCOUNT_ACTIVED_ERROR;
1369     }
1370     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1371 }
1372 
IsActivedCompletedCB(napi_env env,napi_status status,void * data)1373 void IsActivedCompletedCB(napi_env env, napi_status status, void *data)
1374 {
1375     ACCOUNT_LOGD("napi_create_async_work complete");
1376     IsActivedAsyncContext *asyncContext = reinterpret_cast<IsActivedAsyncContext *>(data);
1377     napi_value errJs = nullptr;
1378     napi_value dataJs = nullptr;
1379     if (asyncContext->status == napi_ok) {
1380         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1381         napi_get_boolean(env, asyncContext->isOsAccountActived, &dataJs);
1382     } else {
1383         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1384         if (asyncContext->throwErr) {
1385             napi_get_null(env, &dataJs);
1386         } else {
1387             napi_get_boolean(env, asyncContext->isOsAccountActived, &dataJs);
1388         }
1389     }
1390     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1391     delete asyncContext;
1392 }
1393 
ParseParaIsEnable(napi_env env,napi_callback_info cbInfo,IsConEnableAsyncContext * asyncContext)1394 bool ParseParaIsEnable(napi_env env, napi_callback_info cbInfo, IsConEnableAsyncContext *asyncContext)
1395 {
1396     size_t argc = ARGS_SIZE_THREE;
1397     napi_value argv[ARGS_SIZE_THREE] = {0};
1398     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1399     if (argc == ARGS_SIZE_ONE) {
1400         std::vector<int> ids;
1401         ErrCode errCode = OsAccountManager::QueryActiveOsAccountIds(ids);
1402         if (errCode != ERR_OK) {
1403             ACCOUNT_LOGE("Get id failed");
1404             AccountNapiThrow(env, errCode, asyncContext->throwErr);
1405             return false;
1406         }
1407         if (ids.empty()) {
1408             ACCOUNT_LOGE("No Active OsAccount Ids");
1409             AccountNapiThrow(env, ERR_ACCOUNT_COMMON_INVALID_PARAMETER, asyncContext->throwErr);
1410             return false;
1411         }
1412         asyncContext->id = ids[0];
1413         if (!GetStringProperty(env, argv[PARAMZERO], asyncContext->constraint)) {
1414             ACCOUNT_LOGE("Get constraint failed");
1415             std::string errMsg = "Parameter error. The type of \"constraint\" must be string";
1416             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1417             return false;
1418         }
1419         return true;
1420     }
1421     if (argc == ARGS_SIZE_THREE) {
1422         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1423             ACCOUNT_LOGE("Get callbackRef failed");
1424             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1425             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1426             return false;
1427         }
1428     }
1429 
1430     if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
1431         ACCOUNT_LOGE("Get id failed");
1432         std::string errMsg = "Parameter error. The type of \"localId\" must be number";
1433         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1434         return false;
1435     }
1436     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->constraint)) {
1437         ACCOUNT_LOGE("Get constraint failed");
1438         std::string errMsg = "Parameter error. The type of \"constraint\" must be string";
1439         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1440         return false;
1441     }
1442     return true;
1443 }
1444 
IsEnableExecuteCB(napi_env env,void * data)1445 void IsEnableExecuteCB(napi_env env, void *data)
1446 {
1447     IsConEnableAsyncContext *asyncContext = reinterpret_cast<IsConEnableAsyncContext *>(data);
1448     if (asyncContext->throwErr) {
1449         asyncContext->errCode = OsAccountManager::CheckOsAccountConstraintEnabled(asyncContext->id,
1450             asyncContext->constraint, asyncContext->isConsEnable);
1451     } else {
1452         asyncContext->errCode = OsAccountManager::IsOsAccountConstraintEnable(asyncContext->id,
1453             asyncContext->constraint, asyncContext->isConsEnable);
1454     }
1455 
1456     // for compatibility
1457     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
1458         asyncContext->errCode = ERR_OSACCOUNT_KIT_IS_OS_ACCOUNT_CONSTRAINT_ENABLE_ERROR;
1459     }
1460     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1461 }
1462 
IsEnableCompletedCB(napi_env env,napi_status status,void * data)1463 void IsEnableCompletedCB(napi_env env, napi_status status, void *data)
1464 {
1465     ACCOUNT_LOGD("napi_create_async_work complete");
1466     IsConEnableAsyncContext *asyncContext = reinterpret_cast<IsConEnableAsyncContext *>(data);
1467     napi_value errJs = nullptr;
1468     napi_value dataJs = nullptr;
1469     if (asyncContext->status == napi_ok) {
1470         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1471         napi_get_boolean(env, asyncContext->isConsEnable, &dataJs);
1472     } else {
1473         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1474         if (asyncContext->throwErr) {
1475             napi_get_null(env, &dataJs);
1476         } else {
1477             napi_get_boolean(env, asyncContext->isConsEnable, &dataJs);
1478         }
1479     }
1480     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1481     delete asyncContext;
1482 }
1483 
ParseParaGetType(napi_env env,napi_callback_info cbInfo,GetTypeAsyncContext * asyncContext)1484 bool ParseParaGetType(napi_env env, napi_callback_info cbInfo, GetTypeAsyncContext *asyncContext)
1485 {
1486     size_t argc = ARGS_SIZE_ONE;
1487     napi_value argv[ARGS_SIZE_ONE] = {0};
1488     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1489     if (argc == ARGS_SIZE_ZERO) {
1490         return true;
1491     }
1492 
1493     napi_valuetype valueType = napi_undefined;
1494     napi_typeof(env, argv[PARAMZERO], &valueType);
1495     if (valueType == napi_number) {
1496         napi_get_value_int32(env, argv[PARAMZERO], &(asyncContext->id));
1497         asyncContext->withId = true;
1498     } else if (valueType == napi_function) {
1499         napi_create_reference(env, argv[PARAMZERO], 1, &(asyncContext->callbackRef));
1500     } else {
1501         ACCOUNT_LOGE("Get callbackRef or id failed.");
1502         std::string errMsg = "Parameter error. The type of arg " + std::to_string(argc) + " must be function or number";
1503         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1504         return false;
1505     }
1506     return true;
1507 }
1508 
GetTypeExecuteCB(napi_env env,void * data)1509 void GetTypeExecuteCB(napi_env env, void *data)
1510 {
1511     GetTypeAsyncContext *asyncContext = reinterpret_cast<GetTypeAsyncContext *>(data);
1512     if (asyncContext->withId) {
1513         asyncContext->errCode = OsAccountManager::GetOsAccountType(asyncContext->id, asyncContext->type);
1514     } else {
1515         asyncContext->errCode = OsAccountManager::GetOsAccountTypeFromProcess(asyncContext->type);
1516     }
1517     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1518     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1519 }
1520 
GetTypeCompletedCB(napi_env env,napi_status status,void * data)1521 void GetTypeCompletedCB(napi_env env, napi_status status, void *data)
1522 {
1523     GetTypeAsyncContext *asyncContext = reinterpret_cast<GetTypeAsyncContext *>(data);
1524     napi_value errJs = nullptr;
1525     napi_value dataJs = nullptr;
1526     if (asyncContext->status == napi_ok) {
1527         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1528         int cType = static_cast<int>(asyncContext->type);
1529         napi_create_int32(env, cType, &dataJs);
1530     } else {
1531         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1532         napi_get_null(env, &dataJs);
1533     }
1534     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1535     delete asyncContext;
1536 }
1537 
ParseParaIsMultiEn(napi_env env,napi_callback_info cbInfo,IsMultiEnAsyncContext * asyncContext)1538 bool ParseParaIsMultiEn(napi_env env, napi_callback_info cbInfo, IsMultiEnAsyncContext *asyncContext)
1539 {
1540     return ParseOneParaContext(env, cbInfo, asyncContext);
1541 }
1542 
IsMultiEnExecuteCB(napi_env env,void * data)1543 void IsMultiEnExecuteCB(napi_env env, void *data)
1544 {
1545     IsMultiEnAsyncContext *asyncContext = reinterpret_cast<IsMultiEnAsyncContext *>(data);
1546     asyncContext->errCode = OsAccountManager::IsMultiOsAccountEnable(asyncContext->isMultiOAEnable);
1547     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1548     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1549 }
1550 
IsMultiEnCompletedCB(napi_env env,napi_status status,void * data)1551 void IsMultiEnCompletedCB(napi_env env, napi_status status, void *data)
1552 {
1553     ACCOUNT_LOGD("napi_create_async_work complete");
1554     IsMultiEnAsyncContext *asyncContext = reinterpret_cast<IsMultiEnAsyncContext *>(data);
1555     napi_value errJs = nullptr;
1556     napi_value dataJs = nullptr;
1557     if (asyncContext->status == napi_ok) {
1558         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1559         napi_get_boolean(env, asyncContext->isMultiOAEnable, &dataJs);
1560     } else {
1561         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1562         if (asyncContext->throwErr) {
1563             napi_get_null(env, &dataJs);
1564         } else {
1565             napi_get_boolean(env, asyncContext->isMultiOAEnable, &dataJs);
1566         }
1567     }
1568     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1569     delete asyncContext;
1570 }
1571 
ParseParaIsVerifiedWithOneParam(napi_env env,napi_value value,IsVerifiedAsyncContext * asyncContext)1572 static bool ParseParaIsVerifiedWithOneParam(
1573     napi_env env, napi_value value, IsVerifiedAsyncContext *asyncContext)
1574 {
1575     napi_valuetype valueType = napi_undefined;
1576     napi_typeof(env, value, &valueType);
1577     if (valueType == napi_number) {
1578         if (!GetIntProperty(env, value, asyncContext->id)) {
1579             ACCOUNT_LOGE("Get id failed");
1580             std::string errMsg = "Parameter error. The type of \"localId\" must be number";
1581             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1582             return false;
1583         }
1584         asyncContext->hasAccountId = true;
1585     } else if (valueType == napi_function) {
1586         if (!GetCallbackProperty(env, value, asyncContext->callbackRef, 1)) {
1587             ACCOUNT_LOGE("Get callbackRef failed");
1588             std::string errMsg = "The type of arg 1 must be function";
1589             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1590             return false;
1591         }
1592     } else if ((valueType == napi_undefined) || (valueType == napi_null)) {
1593         ACCOUNT_LOGI("id is undefined or null");
1594     } else {
1595         ACCOUNT_LOGE("Wrong arg type, expected number or function");
1596         std::string errMsg = "The type of arg 1 must be number or function";
1597         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1598         return false;
1599     }
1600     return true;
1601 }
1602 
ParseParaIsVerified(napi_env env,napi_callback_info cbInfo,IsVerifiedAsyncContext * asyncContext)1603 bool ParseParaIsVerified(napi_env env, napi_callback_info cbInfo, IsVerifiedAsyncContext *asyncContext)
1604 {
1605     size_t argc = ARGS_SIZE_TWO;
1606     napi_value argv[ARGS_SIZE_TWO] = {0};
1607     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1608 
1609     if (argc == 0) {
1610         return true;
1611     }
1612     if (argc == ARGS_SIZE_ONE) {
1613         return ParseParaIsVerifiedWithOneParam(env, argv[PARAMZERO], asyncContext);
1614     }
1615     if (argc == ARGS_SIZE_TWO) {
1616         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1617             ACCOUNT_LOGE("Get callbackRef failed");
1618             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1619             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1620             return false;
1621         }
1622         napi_valuetype valueType = napi_undefined;
1623         napi_typeof(env, argv[PARAMZERO], &valueType);
1624         if ((valueType == napi_undefined) || (valueType == napi_null)) {
1625             ACCOUNT_LOGI("id is undefined or null");
1626         } else {
1627             if (!GetIntProperty(env, argv[PARAMZERO], asyncContext->id)) {
1628                 ACCOUNT_LOGE("Get id failed");
1629                 std::string errMsg = "Parameter error. The type of \"localId\" must be number";
1630                 AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1631                 return false;
1632             }
1633             asyncContext->hasAccountId = true;
1634         }
1635     }
1636     return true;
1637 }
1638 
IsVerifiedExecuteCB(napi_env env,void * data)1639 void IsVerifiedExecuteCB(napi_env env, void *data)
1640 {
1641     IsVerifiedAsyncContext *asyncContext = reinterpret_cast<IsVerifiedAsyncContext *>(data);
1642     if (!asyncContext->hasAccountId) {
1643         asyncContext->errCode = OsAccountManager::IsCurrentOsAccountVerified(asyncContext->IsVerified);
1644     } else {
1645         asyncContext->errCode = OsAccountManager::IsOsAccountVerified(asyncContext->id, asyncContext->IsVerified);
1646     }
1647     // for compatibility
1648     if ((!asyncContext->throwErr) && (asyncContext->errCode == ERR_ACCOUNT_COMMON_PERMISSION_DENIED)) {
1649         asyncContext->errCode = ERR_OSACCOUNT_KIT_IS_OS_ACCOUNT_VERIFIED_ERROR;
1650     }
1651     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1652 }
1653 
IsVerifiedCompletedCB(napi_env env,napi_status status,void * data)1654 void IsVerifiedCompletedCB(napi_env env, napi_status status, void *data)
1655 {
1656     ACCOUNT_LOGD("napi_create_async_work complete");
1657     IsVerifiedAsyncContext *asyncContext = reinterpret_cast<IsVerifiedAsyncContext *>(data);
1658     napi_value errJs = nullptr;
1659     napi_value dataJs = nullptr;
1660     if (asyncContext->status == napi_ok) {
1661         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1662         napi_get_boolean(env, asyncContext->IsVerified, &dataJs);
1663     } else {
1664         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1665         if (asyncContext->throwErr) {
1666             napi_get_null(env, &dataJs);
1667         } else {
1668             napi_get_boolean(env, asyncContext->IsVerified, &dataJs);
1669         }
1670     }
1671     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1672     delete asyncContext;
1673 }
1674 
ParseParaSerialNumId(napi_env env,napi_callback_info cbInfo,GetSerialNumIdCBInfo * asyncContext)1675 bool ParseParaSerialNumId(napi_env env, napi_callback_info cbInfo, GetSerialNumIdCBInfo *asyncContext)
1676 {
1677     size_t argc = ARGS_SIZE_TWO;
1678     napi_value argv[ARGS_SIZE_TWO] = {0};
1679     napi_get_cb_info(env, cbInfo, &argc, argv, nullptr, nullptr);
1680     if (argc == ARGS_SIZE_TWO) {
1681         if (!GetCallbackProperty(env, argv[argc - 1], asyncContext->callbackRef, 1)) {
1682             ACCOUNT_LOGE("Get callbackRef failed");
1683             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1684             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1685             return false;
1686         }
1687     }
1688     if (!GetLongIntProperty(env, argv[PARAMZERO], asyncContext->serialNumber)) {
1689         ACCOUNT_LOGE("Get serialNumber failed");
1690         std::string errMsg = "Parameter error. The type of \"serialNumber\" must be number";
1691         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1692         return false;
1693     }
1694 
1695     return true;
1696 }
1697 
SerialNumIdExecuteCB(napi_env env,void * data)1698 void SerialNumIdExecuteCB(napi_env env, void *data)
1699 {
1700     GetSerialNumIdCBInfo *asyncContext = reinterpret_cast<GetSerialNumIdCBInfo *>(data);
1701     asyncContext->errCode =
1702         OsAccountManager::GetOsAccountLocalIdBySerialNumber(asyncContext->serialNumber, asyncContext->id);
1703     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1704 }
1705 
SerialNumIdCompletedCB(napi_env env,napi_status status,void * data)1706 void SerialNumIdCompletedCB(napi_env env, napi_status status, void *data)
1707 {
1708     GetSerialNumIdCBInfo *asyncContext = reinterpret_cast<GetSerialNumIdCBInfo *>(data);
1709     napi_value errJs = nullptr;
1710     napi_value dataJs = nullptr;
1711     if (asyncContext->status == napi_ok) {
1712         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1713         napi_create_int32(env, asyncContext->id, &dataJs);
1714     } else {
1715         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1716         if (asyncContext->throwErr) {
1717             napi_get_null(env, &dataJs);
1718         } else {
1719             napi_create_int32(env, asyncContext->id, &dataJs);
1720         }
1721     }
1722     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1723     delete asyncContext;
1724 }
1725 
ParseParaGetSerialNum(napi_env env,napi_callback_info cbInfo,GetSerialNumForOAInfo * asyncContext)1726 bool ParseParaGetSerialNum(napi_env env, napi_callback_info cbInfo, GetSerialNumForOAInfo *asyncContext)
1727 {
1728     return ParseCallbackAndId(env, cbInfo, asyncContext->callbackRef, asyncContext->id, asyncContext->throwErr);
1729 }
1730 
GetSerialNumExecuteCB(napi_env env,void * data)1731 void GetSerialNumExecuteCB(napi_env env, void *data)
1732 {
1733     GetSerialNumForOAInfo *asyncContext = reinterpret_cast<GetSerialNumForOAInfo *>(data);
1734     asyncContext->errCode =
1735         OsAccountManager::GetSerialNumberByOsAccountLocalId(asyncContext->id, asyncContext->serialNum);
1736     ACCOUNT_LOGD("error code is %{public}d", asyncContext->errCode);
1737     asyncContext->status = (asyncContext->errCode == 0) ? napi_ok : napi_generic_failure;
1738 }
1739 
GetSerialNumCompletedCB(napi_env env,napi_status status,void * data)1740 void GetSerialNumCompletedCB(napi_env env, napi_status status, void *data)
1741 {
1742     ACCOUNT_LOGD("napi_create_async_work complete");
1743     GetSerialNumForOAInfo *asyncContext = reinterpret_cast<GetSerialNumForOAInfo *>(data);
1744     napi_value errJs = nullptr;
1745     napi_value dataJs = nullptr;
1746     if (asyncContext->status == napi_ok) {
1747         errJs = GenerateBusinessSuccess(env, asyncContext->throwErr);
1748         napi_create_int64(env, asyncContext->serialNum, &dataJs);
1749     } else {
1750         errJs = GenerateBusinessError(env, asyncContext->errCode, asyncContext->throwErr);
1751         if (asyncContext->throwErr) {
1752             napi_get_null(env, &dataJs);
1753         } else {
1754             napi_create_int64(env, asyncContext->serialNum, &dataJs);
1755         }
1756     }
1757     ProcessCallbackOrPromise(env, asyncContext, errJs, dataJs);
1758     delete asyncContext;
1759 }
1760 
ParseParaIsTestOA(napi_env env,napi_callback_info cbInfo,IsTestOAInfo * asyncContext)1761 bool ParseParaIsTestOA(napi_env env, napi_callback_info cbInfo, IsTestOAInfo *asyncContext)
1762 {
1763     return ParseOneParaContext(env, cbInfo, asyncContext);
1764 }
1765 
ParseParaIsMainOA(napi_env env,napi_callback_info cbInfo,IsMainOAInfo * asyncContext)1766 bool ParseParaIsMainOA(napi_env env, napi_callback_info cbInfo, IsMainOAInfo *asyncContext)
1767 {
1768     return ParseOneParaContext(env, cbInfo, asyncContext);
1769 }
1770 
ParseParamForActiveSubscriber(const napi_env & env,const std::string & type,SubscribeCBInfo * asyncContext,size_t argc,napi_value * argv)1771 static bool ParseParamForActiveSubscriber(const napi_env &env, const std::string &type, SubscribeCBInfo *asyncContext,
1772                                           size_t argc, napi_value *argv)
1773 {
1774     if (argc < ARGS_SIZE_THREE) {
1775         ACCOUNT_LOGE("The arg number less than 3 characters");
1776         std::string errMsg = "Parameter error. The number of parameters should be at least 3";
1777         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1778         return false;
1779     }
1780     if (argc >= ARGS_SIZE_THREE) {
1781         if (!GetCallbackProperty(env, argv[PARAMTWO], asyncContext->callbackRef, 1)) {
1782             ACCOUNT_LOGE("Get callbackRef failed");
1783             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1784             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1785             return false;
1786         }
1787     }
1788 
1789     // argv[0] type: 'activate' | 'activating'
1790     if (type == "activate") {
1791         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVED;
1792     } else {
1793         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVATING;
1794     }
1795 
1796     // argv[1] name: string
1797     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->name)) {
1798         ACCOUNT_LOGE("Get name failed");
1799         std::string errMsg = "Parameter error. The type of \"name\" must be string";
1800         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1801         return false;
1802     }
1803     size_t nameSize = asyncContext->name.size();
1804     if (nameSize == 0 || nameSize > MAX_SUBSCRIBER_NAME_LEN) {
1805         ACCOUNT_LOGE("Subscriber name size %{public}zu is invalid.", nameSize);
1806         std::string errMsg = "Parameter error. The length of \"name\" is invalid";
1807         AccountNapiThrow(env, ERR_JS_INVALID_PARAMETER, errMsg, asyncContext->throwErr);
1808         return false;
1809     }
1810 
1811     return true;
1812 }
1813 
ParseParamForSwitchSubscriber(const napi_env & env,const std::string & type,SubscribeCBInfo * asyncContext,size_t argc,napi_value * argv)1814 static bool ParseParamForSwitchSubscriber(const napi_env &env, const std::string &type, SubscribeCBInfo *asyncContext,
1815                                           size_t argc, napi_value *argv)
1816 {
1817     if (argc < ARGS_SIZE_TWO) {
1818         ACCOUNT_LOGE("The number of parameters should be at least 2");
1819         std::string errMsg = "Parameter error. The number of parameters should be at least 2";
1820         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1821         return false;
1822     }
1823     if (argc >= ARGS_SIZE_TWO) {
1824         if (!GetCallbackProperty(env, argv[PARAMONE], asyncContext->callbackRef, 1)) {
1825             ACCOUNT_LOGE("Get callbackRef failed");
1826             std::string errMsg = "Parameter error. The type of \"callback\" must be function";
1827             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1828             return false;
1829         }
1830     }
1831     // argv[0] type: 'switched' | 'switching'
1832     if (type == "switched") {
1833         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::SWITCHED;
1834     } else {
1835         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::SWITCHING;
1836     }
1837 
1838     return true;
1839 }
1840 
ParseParaToSubscriber(const napi_env & env,napi_callback_info cbInfo,SubscribeCBInfo * asyncContext,napi_value * thisVar)1841 bool ParseParaToSubscriber(const napi_env &env, napi_callback_info cbInfo, SubscribeCBInfo *asyncContext,
1842                            napi_value *thisVar)
1843 {
1844     size_t argc = ARGS_SIZE_THREE;
1845     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
1846     NAPI_CALL_BASE(env, napi_get_cb_info(env, cbInfo, &argc, argv, thisVar, NULL), false);
1847     if (argc < ARGS_SIZE_TWO) {
1848         ACCOUNT_LOGE("The number of parameters should be at least 2");
1849         std::string errMsg = "Parameter error. The number of parameters should be at least 2";
1850         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1851         return false;
1852     }
1853     std::string type;
1854     if (!GetStringProperty(env, argv[PARAMZERO], type)) {
1855         ACCOUNT_LOGE("Get type failed.");
1856         std::string errMsg = "Parameter error. The type of \"type\" must be string";
1857         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1858         return false;
1859     }
1860     if ((type == "activate" || type == "activating")) {
1861         return ParseParamForActiveSubscriber(env, type, asyncContext, argc, argv);
1862     }
1863     if (type == "switched" || type == "switching") {
1864         return ParseParamForSwitchSubscriber(env, type, asyncContext, argc, argv);
1865     }
1866     ACCOUNT_LOGE("Get type fail, %{public}s is invalid.", type.c_str());
1867     std::string errMsg = "Parameter error. The content of \"type\" must be \"activate|activating|switched|switching\"";
1868     AccountNapiThrow(env, ERR_JS_INVALID_PARAMETER, errMsg, asyncContext->throwErr);
1869     return false;
1870 }
1871 
ParseParamForActiveUnsubscriber(const napi_env & env,const std::string & type,UnsubscribeCBInfo * asyncContext,size_t argc,napi_value * argv)1872 static bool ParseParamForActiveUnsubscriber(const napi_env &env, const std::string &type,
1873                                             UnsubscribeCBInfo *asyncContext, size_t argc, napi_value *argv)
1874 {
1875     if (argc < ARGS_SIZE_TWO) {
1876         ACCOUNT_LOGE("The arg number less than 2 characters.");
1877         std::string errMsg = "The arg number must be at least 2 characters";
1878         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1879         return false;
1880     }
1881     if (argc >= ARGS_SIZE_THREE) {
1882         if (!GetCallbackProperty(env, argv[PARAMTWO], asyncContext->callbackRef, 1)) {
1883             ACCOUNT_LOGE("Get callbackRef failed.");
1884             std::string errMsg = "The type of arg " + std::to_string(PARAMTWO + 1) + " must be function";
1885             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1886             return false;
1887         }
1888     }
1889 
1890     // argv[0] type: 'activate' | 'activating'
1891     if (type == "activate") {
1892         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVED;
1893     } else {
1894         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVATING;
1895     }
1896 
1897     // argv[1] name: string
1898     if (!GetStringProperty(env, argv[PARAMONE], asyncContext->name)) {
1899         ACCOUNT_LOGE("Get name failed");
1900         std::string errMsg = "The type of arg 2 must be string";
1901         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1902         return false;
1903     }
1904     size_t nameSize = asyncContext->name.size();
1905     if (nameSize == 0 || nameSize > MAX_SUBSCRIBER_NAME_LEN) {
1906         ACCOUNT_LOGE("Subscriber name size %{public}zu is invalid.", nameSize);
1907         std::string errMsg = "The length of arg 2 is invalid";
1908         AccountNapiThrow(env, ERR_JS_INVALID_PARAMETER, errMsg, asyncContext->throwErr);
1909         return false;
1910     }
1911 
1912     return true;
1913 }
1914 
ParseParamForSwitchUnsubscriber(const napi_env & env,const std::string & type,UnsubscribeCBInfo * asyncContext,size_t argc,napi_value * argv)1915 static bool ParseParamForSwitchUnsubscriber(const napi_env &env, const std::string &type,
1916                                             UnsubscribeCBInfo *asyncContext, size_t argc, napi_value *argv)
1917 {
1918     if (argc < ARGS_SIZE_ONE) {
1919         ACCOUNT_LOGE("The arg number less than 1 characters.");
1920         std::string errMsg = "The arg number must be at least 1 characters";
1921         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1922         return false;
1923     }
1924     if (argc >= ARGS_SIZE_TWO) {
1925         if (!GetCallbackProperty(env, argv[PARAMONE], asyncContext->callbackRef, 1)) {
1926             ACCOUNT_LOGE("Get callbackRef failed.");
1927             std::string errMsg = "The type of arg " + std::to_string(PARAMONE + 1) + " must be function";
1928             AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1929             return false;
1930         }
1931     }
1932     // argv[0] type: 'switched' | 'switching'
1933     if (type == "switched") {
1934         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::SWITCHED;
1935     } else {
1936         asyncContext->osSubscribeType = OS_ACCOUNT_SUBSCRIBE_TYPE::SWITCHING;
1937     }
1938 
1939     return true;
1940 }
1941 
ParseParaToUnsubscriber(const napi_env & env,napi_callback_info cbInfo,UnsubscribeCBInfo * asyncContext,napi_value * thisVar)1942 bool ParseParaToUnsubscriber(const napi_env &env, napi_callback_info cbInfo, UnsubscribeCBInfo *asyncContext,
1943                              napi_value *thisVar)
1944 {
1945     size_t argc = ARGS_SIZE_THREE;
1946     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
1947     NAPI_CALL_BASE(env, napi_get_cb_info(env, cbInfo, &argc, argv, thisVar, NULL), false);
1948     if (argc < ARGS_SIZE_ONE) {
1949         ACCOUNT_LOGE("The arg number less than 1 characters.");
1950         std::string errMsg = "Parameter error. The number of parameters should be at least 1";
1951         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1952         return false;
1953     }
1954     std::string type;
1955     if (!GetStringProperty(env, argv[PARAMZERO], type)) {
1956         ACCOUNT_LOGE("Get type failed.");
1957         std::string errMsg = "Parameter error. The type of \"type\" must be string";
1958         AccountNapiThrow(env, ERR_JS_PARAMETER_ERROR, errMsg, asyncContext->throwErr);
1959         return false;
1960     }
1961     if ((type == "activate" || type == "activating")) {
1962         return ParseParamForActiveUnsubscriber(env, type, asyncContext, argc, argv);
1963     }
1964     if (type == "switched" || type == "switching") {
1965         return ParseParamForSwitchUnsubscriber(env, type, asyncContext, argc, argv);
1966     }
1967     ACCOUNT_LOGE("Get type fail, %{public}s is invalid.", type.c_str());
1968     std::string errMsg = "Parameter error. The content of \"type\" must be \"activate|activating|switched|switching\"";
1969     AccountNapiThrow(env, ERR_JS_INVALID_PARAMETER, errMsg, asyncContext->throwErr);
1970     return false;
1971 }
1972 }  // namespace AccountJsKit
1973 }  // namespace OHOS
1974