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