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