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