1 /*
2 * Copyright (c) 2021-2023 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 "contacts_api.h"
17
18 #include <mutex>
19
20 #include "datashare_predicates.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24 #include "rdb_predicates.h"
25 #include "rdb_store.h"
26 #include "result_set.h"
27 #include "securec.h"
28
29 #include "contacts_control.h"
30 #include "contacts_napi_common.h"
31 #include "contacts_napi_utils.h"
32 #include "hilog_wrapper_api.h"
33 #include "result_convert.h"
34
35 namespace OHOS {
36 namespace ContactsApi {
37 namespace {
38 std::mutex g_mutex;
39 }
40 /**
41 * @brief Initialize NAPI object
42 *
43 * @param env Conditions for initialize operation
44 * @param object Conditions for initialize operation
45 * @param hold Attribute of object
46 * @param attr Attribute of object
47 * @param contact Attribute of object
48 */
ObjectInit(napi_env env,napi_value object,napi_value & hold,napi_value & attr,napi_value & contact)49 void ObjectInit(napi_env env, napi_value object, napi_value &hold, napi_value &attr, napi_value &contact)
50 {
51 int type = GetType(env, object);
52 switch (type) {
53 case TYPE_HOLDER:
54 hold = object;
55 break;
56 case TYPE_ATTR:
57 attr = object;
58 break;
59 case TYPE_CONTACT:
60 contact = object;
61 break;
62 default:
63 break;
64 }
65 }
66
67 /**
68 * @brief Initialize NAPI number object
69 *
70 * @param env Conditions for initialize operation
71 * @param object Conditions for initialize operation
72 * @param id Number object
73 */
ObjectInitId(napi_env env,napi_value object,napi_value & id)74 void ObjectInitId(napi_env env, napi_value object, napi_value &id)
75 {
76 int type = GetType(env, object);
77 switch (type) {
78 case TYPE_NAPI_NUMBER:
79 id = object;
80 break;
81 default:
82 break;
83 }
84 }
85
86 /**
87 * @brief Initialize NAPI string object
88 *
89 * @param env Conditions for initialize operation
90 * @param object Conditions for initialize operation
91 * @param key String object
92 */
ObjectInitString(napi_env env,napi_value object,napi_value & key)93 void ObjectInitString(napi_env env, napi_value object, napi_value &key)
94 {
95 int type = GetType(env, object);
96 switch (type) {
97 case TYPE_NAPI_STRING:
98 key = object;
99 break;
100 default:
101 break;
102 }
103 }
104
105 /**
106 * @brief Get NAPI object type
107 *
108 * @param env Conditions for get type operation
109 * @param value Conditions for get type operation
110 *
111 * @return The result returned by get type operation
112 */
GetType(napi_env env,napi_value value)113 int GetType(napi_env env, napi_value value)
114 {
115 napi_valuetype valueType;
116 napi_typeof(env, value, &valueType);
117 bool result = false;
118 switch (valueType) {
119 case napi_number:
120 return TYPE_NAPI_NUMBER;
121 break;
122 case napi_string:
123 return TYPE_NAPI_STRING;
124 break;
125 case napi_object:
126 napi_value key;
127 napi_create_string_utf8(env, "bundleName", NAPI_AUTO_LENGTH, &key);
128 napi_has_property(env, value, key, &result);
129 if (result) {
130 return TYPE_HOLDER;
131 }
132 napi_create_string_utf8(env, "attributes", NAPI_AUTO_LENGTH, &key);
133 napi_has_property(env, value, key, &result);
134 if (result) {
135 return TYPE_ATTR;
136 }
137 return TYPE_CONTACT;
138 break;
139 default:
140 return TYPE_NAPI_ERROR;
141 break;
142 }
143 }
144
145 /**
146 * @brief Get dataShareHelper
147 *
148 * @param env Conditions for get dataShareHelper operation
149 *
150 * @return The result returned by get dataShareHelper
151 */
GetDataShareHelper(napi_env env,napi_callback_info info,ExecuteHelper * executeHelper)152 bool GetDataShareHelper(napi_env env, napi_callback_info info, ExecuteHelper *executeHelper)
153 {
154 napi_value global;
155 bool isStageMode = false;
156 napi_value abilityContext = nullptr;
157 napi_status status = napi_get_global(env, &global);
158 if (executeHelper->abilityContext != nullptr) {
159 isStageMode = true;
160 status = napi_ok;
161 abilityContext = executeHelper->abilityContext;
162 } else {
163 if (status != napi_ok) {
164 HILOG_ERROR("GetDataShareHelper napi_get_global != napi_ok");
165 }
166 napi_value globalThis;
167 status = napi_get_named_property(env, global, "globalThis", &globalThis);
168 if (status != napi_ok) {
169 HILOG_ERROR("GetDataShareHelper napi_get_globalThis != napi_ok");
170 }
171 status = napi_get_named_property(env, globalThis, "abilityContext", &abilityContext);
172 if (status != napi_ok) {
173 HILOG_ERROR("GetDataShareHelper napi_get_abilityContext != napi_ok");
174 }
175 status = OHOS::AbilityRuntime::IsStageContext(env, abilityContext, isStageMode);
176 }
177
178 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = nullptr;
179 if (status != napi_ok || !isStageMode) {
180 HILOG_INFO("GetFAModeContext");
181 auto ability = OHOS::AbilityRuntime::GetCurrentAbility(env);
182 if (ability == nullptr) {
183 HILOG_ERROR("Failed to get native ability instance");
184 return false;
185 }
186 auto context = ability->GetContext();
187 if (context == nullptr) {
188 HILOG_ERROR("Failed to get native context instance");
189 return false;
190 }
191 executeHelper->dataShareHelper = DataShare::DataShareHelper::Creator(context->GetToken(), CONTACTS_DATA_URI);
192 } else {
193 HILOG_INFO("GetStageModeContext");
194 auto context = OHOS::AbilityRuntime::GetStageModeContext(env, abilityContext);
195 if (context == nullptr) {
196 HILOG_ERROR("Failed to get native stage context instance");
197 return false;
198 }
199 executeHelper->dataShareHelper = DataShare::DataShareHelper::Creator(context->GetToken(), CONTACTS_DATA_URI);
200 }
201 return false;
202 }
203
204 /**
205 * @brief Establish predicates condition by holder object
206 *
207 * @param holder Conditions for establish predicates operation
208 * @param predicates Conditions for establish predicates operation
209 */
HolderPredicates(Holder & holder,DataShare::DataSharePredicates & predicates)210 void HolderPredicates(Holder &holder, DataShare::DataSharePredicates &predicates)
211 {
212 if (!holder.bundleName.empty()) {
213 predicates.And();
214 predicates.EqualTo("account_type", holder.bundleName);
215 }
216 if (!holder.displayName.empty()) {
217 predicates.And();
218 predicates.EqualTo("account_name", holder.displayName);
219 }
220 if (holder.holderId > 0) {
221 predicates.And();
222 predicates.EqualTo("account_id", std::to_string(holder.holderId));
223 }
224 }
225
226 /**
227 * @brief Establish predicates condition by attributes object
228 *
229 * @param attrs Conditions for establish predicates operation
230 * @param predicates Conditions for establish predicates operation
231 */
AttributesPredicates(bool isBegin,ContactAttributes & attrs,DataShare::DataSharePredicates & predicates)232 void AttributesPredicates(bool isBegin, ContactAttributes &attrs, DataShare::DataSharePredicates &predicates)
233 {
234 unsigned int size = attrs.attributes.size();
235 if (size > 0) {
236 if (!isBegin) {
237 predicates.And();
238 }
239 predicates.BeginWrap();
240 }
241 for (unsigned int i = 0; i < size; ++i) {
242 predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
243 if (i != size - 1) {
244 predicates.Or();
245 }
246 }
247 if (size > 0) {
248 predicates.EndWrap();
249 }
250 }
251
CheckAttributes(ContactAttributes & attrs)252 void CheckAttributes(ContactAttributes &attrs)
253 {
254 unsigned int size = attrs.attributes.size();
255 if (size == 0) {
256 HILOG_INFO("attributes not exist, it means all attribute");
257 attrs.attributes.push_back(EMAIL);
258 attrs.attributes.push_back(IM);
259 attrs.attributes.push_back(NICKNAME);
260 attrs.attributes.push_back(ORGANIZATION);
261 attrs.attributes.push_back(PHONE);
262 attrs.attributes.push_back(NAME);
263 attrs.attributes.push_back(POSTAL_ADDRESS);
264 attrs.attributes.push_back(PHOTO);
265 attrs.attributes.push_back(GROUP_MEMBERSHIP);
266 attrs.attributes.push_back(NOTE);
267 attrs.attributes.push_back(CONTACT_EVENT);
268 attrs.attributes.push_back(WEBSITE);
269 attrs.attributes.push_back(RELATION);
270 attrs.attributes.push_back(SIP_ADDRESS);
271 }
272 }
273
274 /**
275 * @brief Resolve object interface in DELETE_CONTACT case
276 *
277 * @param env Conditions for resolve object interface operation
278 * @param info Conditions for resolve object interface operation
279 */
BuildDeleteContactPredicates(napi_env env,ExecuteHelper * executeHelper)280 DataShare::DataSharePredicates BuildDeleteContactPredicates(napi_env env, ExecuteHelper *executeHelper)
281 {
282 DataShare::DataSharePredicates predicates;
283 ContactsBuild contactsBuild;
284 std::string keyValue = contactsBuild.NapiGetValueString(env, executeHelper->argv[0]);
285 if (!keyValue.empty()) {
286 predicates.EqualTo("is_deleted", "0");
287 predicates.And();
288 predicates.EqualTo("quick_search_key", keyValue);
289 }
290 return predicates;
291 }
292
293 /**
294 * @brief Resolve object interface in QUERY_CONTACT case
295 *
296 * @param env Conditions for resolve object interface operation
297 * @param key Conditions for resolve object interface operation
298 * @param hold Conditions for resolve object interface operation
299 * @param attr Conditions for resolve object interface operation
300 */
BuildQueryContactPredicates(napi_env env,napi_value key,napi_value hold,napi_value attr)301 DataShare::DataSharePredicates BuildQueryContactPredicates(
302 napi_env env, napi_value key, napi_value hold, napi_value attr)
303 {
304 ContactsBuild contactsBuild;
305 std::string keyValue = contactsBuild.NapiGetValueString(env, key);
306 Holder holder = contactsBuild.GetHolder(env, hold);
307 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
308 DataShare::DataSharePredicates predicates;
309 if (!keyValue.empty()) {
310 predicates.EqualTo("is_deleted", "0");
311 predicates.And();
312 predicates.EqualTo("quick_search_key", keyValue);
313 HolderPredicates(holder, predicates);
314 AttributesPredicates(false, attrs, predicates);
315 }
316 return predicates;
317 }
318
HoldersStructure(std::map<std::string,std::string> & holders,Holder & holder)319 void HoldersStructure(std::map<std::string, std::string> &holders, Holder &holder)
320 {
321 if (!holder.bundleName.empty()) {
322 holders["account_type"] = holder.bundleName;
323 }
324 if (!holder.displayName.empty()) {
325 holders["account_name"] = holder.displayName;
326 }
327 if (holder.holderId > 0) {
328 holders["account_id"] = std::to_string(holder.holderId);
329 }
330 }
331
332 /**
333 * @brief Resolve object interface in QUERY_CONTACTS case
334 *
335 * @param env Conditions for resolve object interface operation
336 * @param hold Conditions for resolve object interface operation
337 * @param attr Conditions for resolve object interface operation
338 */
BuildQueryContactsPredicates(napi_env env,napi_value hold,napi_value attr)339 DataShare::DataSharePredicates BuildQueryContactsPredicates(napi_env env, napi_value hold, napi_value attr)
340 {
341 ContactsBuild contactsBuild;
342 Holder holder = contactsBuild.GetHolder(env, hold);
343 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
344 DataShare::DataSharePredicates predicates;
345 std::map<std::string, std::string> holders;
346 HoldersStructure(holders, holder);
347 unsigned int size = attrs.attributes.size();
348 unsigned int mapSize = holders.size();
349 std::map<std::string, std::string>::iterator it;
350 for (it = holders.begin(); it != holders.end(); ++it) {
351 predicates.EqualTo(it->first, it->second);
352 if (it != --holders.end()) {
353 predicates.And();
354 }
355 }
356 if (mapSize > 0) {
357 predicates.And();
358 }
359 if (size > 0) {
360 predicates.BeginWrap();
361 }
362 for (unsigned int i = 0; i < size; ++i) {
363 predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
364 if (i != size - 1) {
365 predicates.Or();
366 }
367 }
368 if (size > 0) {
369 predicates.EndWrap();
370 }
371 if (size > 0 || mapSize > 0) {
372 predicates.And();
373 }
374 predicates.EqualTo("is_deleted", "0");
375 return predicates;
376 }
377
378 /**
379 * @brief Resolve object interface in QUERY_CONTACTS_BY_EMAIL case
380 *
381 * @param env Conditions for resolve object interface operation
382 * @param emailobject Conditions for resolve object interface operation
383 * @param hold Conditions for resolve object interface operation
384 * @param attr Conditions for resolve object interface operation
385 */
BuildQueryContactsByEmailPredicates(napi_env env,napi_value emailobject,napi_value hold,napi_value attr)386 DataShare::DataSharePredicates BuildQueryContactsByEmailPredicates(
387 napi_env env, napi_value emailobject, napi_value hold, napi_value attr)
388 {
389 ContactsBuild contactsBuild;
390 std::string email = contactsBuild.NapiGetValueString(env, emailobject);
391 Holder holder = contactsBuild.GetHolder(env, hold);
392 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
393 DataShare::DataSharePredicates predicates;
394 if (!email.empty() || email != "") {
395 predicates.EqualTo("is_deleted", "0");
396 predicates.And();
397 predicates.EqualTo("detail_info", email);
398 predicates.And();
399 predicates.EqualTo("content_type", "email");
400 HolderPredicates(holder, predicates);
401 AttributesPredicates(false, attrs, predicates);
402 }
403 return predicates;
404 }
405
406 /**
407 * @brief Resolve object interface in QUERY_CONTACTS_BY_PHONE_NUMBER case
408 *
409 * @param env Conditions for resolve object interface operation
410 * @param number Conditions for resolve object interface operation
411 * @param hold Conditions for resolve object interface operation
412 * @param attr Conditions for resolve object interface operation
413 */
BuildQueryContactsByPhoneNumberPredicates(napi_env env,napi_value number,napi_value hold,napi_value attr)414 DataShare::DataSharePredicates BuildQueryContactsByPhoneNumberPredicates(
415 napi_env env, napi_value number, napi_value hold, napi_value attr)
416 {
417 ContactsBuild contactsBuild;
418 std::string phoneNumber = contactsBuild.NapiGetValueString(env, number);
419 Holder holder = contactsBuild.GetHolder(env, hold);
420 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
421 DataShare::DataSharePredicates predicates;
422 if (!phoneNumber.empty() || phoneNumber != "") {
423 predicates.EqualTo("is_deleted", "0");
424 predicates.And();
425 predicates.EqualTo("detail_info", phoneNumber);
426 predicates.And();
427 predicates.EqualTo("content_type", "phone");
428 HolderPredicates(holder, predicates);
429 AttributesPredicates(false, attrs, predicates);
430 }
431 return predicates;
432 }
433
434 /**
435 * @brief Resolve object interface in QUERY_GROUPS case
436 *
437 * @param env Conditions for resolve object interface operation
438 * @param hold Conditions for resolve object interface operation
439 */
BuildQueryGroupsPredicates(napi_env env,napi_value hold)440 DataShare::DataSharePredicates BuildQueryGroupsPredicates(napi_env env, napi_value hold)
441 {
442 ContactsBuild contactsBuild;
443 Holder holder = contactsBuild.GetHolder(env, hold);
444 DataShare::DataSharePredicates predicates;
445 std::map<std::string, std::string> holders;
446 HoldersStructure(holders, holder);
447 predicates.EqualTo("is_deleted", "0");
448 unsigned int size = holders.size();
449 if (size > 0) {
450 predicates.And();
451 }
452 std::map<std::string, std::string>::iterator it;
453 for (it = holders.begin(); it != holders.end(); ++it) {
454 predicates.EqualTo(it->first, it->second);
455 if (it != --holders.end()) {
456 predicates.And();
457 }
458 }
459 return predicates;
460 }
461
462 /**
463 * @brief Resolve object interface in QUERY_KEY case
464 *
465 * @param env Conditions for resolve object interface operation
466 * @param id Conditions for resolve object interface operation
467 * @param hold Conditions for resolve object interface operation
468 */
BuildQueryKeyPredicates(napi_env env,napi_value id,napi_value hold)469 DataShare::DataSharePredicates BuildQueryKeyPredicates(napi_env env, napi_value id, napi_value hold)
470 {
471 ContactsBuild contactsBuild;
472 int value = contactsBuild.GetInt(env, id);
473 Holder holder = contactsBuild.GetHolder(env, hold);
474 DataShare::DataSharePredicates predicates;
475 if (value != 0) {
476 predicates.EqualTo("is_deleted", "0");
477 predicates.And();
478 predicates.EqualTo("contact_id", std::to_string(value));
479 HolderPredicates(holder, predicates);
480 }
481 return predicates;
482 }
483
484 /**
485 * @brief Resolve object interface in QUERY_MY_CARD case
486 *
487 * @param env Conditions for resolve object interface operation
488 * @param attr Conditions for resolve object interface operation
489 */
BuildQueryMyCardPredicates(napi_env env,napi_value attr)490 DataShare::DataSharePredicates BuildQueryMyCardPredicates(napi_env env, napi_value attr)
491 {
492 ContactsBuild contactsBuild;
493 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
494 DataShare::DataSharePredicates predicates;
495 unsigned int size = attrs.attributes.size();
496 predicates.EqualTo("is_deleted", "0");
497 if (size > 0) {
498 predicates.And();
499 }
500 for (unsigned int i = 0; i < size; ++i) {
501 predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
502 if (i != size - 1) {
503 predicates.Or();
504 }
505 }
506 return predicates;
507 }
508
BuildQueryContactData(napi_env env,napi_value & contactObject,napi_value & attrObject,std::vector<DataShare::DataShareValuesBucket> & valueContactData)509 DataShare::DataSharePredicates BuildQueryContactData(napi_env env, napi_value &contactObject, napi_value &attrObject,
510 std::vector<DataShare::DataShareValuesBucket> &valueContactData)
511 {
512 ContactsBuild contactsBuild;
513 Contacts contact;
514 contactsBuild.GetContactDataByObject(env, contactObject, contact);
515 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attrObject);
516 CheckAttributes(attrs);
517 DataShare::DataSharePredicates predicates;
518 std::vector<std::string> fields;
519 fields.push_back("raw_contact_id");
520 if (contact.id != 0) {
521 predicates.EqualTo("is_deleted", "0");
522 predicates.And();
523 predicates.EqualTo("contact_id", std::to_string(contact.id));
524 predicates.GroupBy(fields);
525 }
526 unsigned int size = attrs.attributes.size();
527 for (unsigned int i = 0; i < size; i++) {
528 contactsBuild.BuildValueContactDataByType(contact, attrs.attributes[i], valueContactData);
529 }
530 return predicates;
531 }
532
BuildUpdateContactColumns()533 std::vector<std::string> BuildUpdateContactColumns()
534 {
535 std::vector<std::string> columns;
536 columns.push_back("raw_contact_id");
537 return columns;
538 }
539
GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)540 int GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
541 {
542 if (resultSet == nullptr) {
543 return -1;
544 }
545 int resultSetNum = resultSet->GoToFirstRow();
546 int intValue = 0;
547 while (resultSetNum == OHOS::NativeRdb::E_OK) {
548 resultSet->GetInt(0, intValue);
549 resultSetNum = resultSet->GoToNextRow();
550 }
551 resultSet->Close();
552 return intValue;
553 }
554
BuildUpdateContactConvertParams(napi_env env,napi_value & contact,napi_value & attr,ExecuteHelper * executeHelper)555 DataShare::DataSharePredicates BuildUpdateContactConvertParams(napi_env env, napi_value &contact,
556 napi_value &attr, ExecuteHelper *executeHelper)
557 {
558 executeHelper->valueContactData.clear();
559 DataShare::DataSharePredicates predicates =
560 BuildQueryContactData(env, contact, attr, executeHelper->valueContactData);
561 executeHelper->columns = BuildUpdateContactColumns();
562 executeHelper->deletePredicates = BuildDeleteContactDataPredicates(env, attr);
563 return predicates;
564 }
565
BuildDeleteContactDataPredicates(napi_env env,napi_value attr)566 DataShare::DataSharePredicates BuildDeleteContactDataPredicates(napi_env env, napi_value attr)
567 {
568 ContactsBuild contactsBuild;
569 ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
570 CheckAttributes(attrs);
571 DataShare::DataSharePredicates predicates;
572 AttributesPredicates(true, attrs, predicates);
573 return predicates;
574 }
575
576 /**
577 * @brief Resolve object interface in IS_LOCAL_CONTACT case
578 *
579 * @param env Conditions for resolve object interface operation
580 * @param id Conditions for resolve object interface operation
581 */
BuildIsLocalContactPredicates(napi_env env,napi_value id)582 DataShare::DataSharePredicates BuildIsLocalContactPredicates(napi_env env, napi_value id)
583 {
584 ContactsBuild contactsBuild;
585 int value = contactsBuild.GetInt(env, id);
586 DataShare::DataSharePredicates predicates;
587 if (value != 0) {
588 predicates.EqualTo("is_deleted", "0");
589 predicates.And();
590 predicates.EqualTo("contact_id", std::to_string(value));
591 predicates.And();
592 predicates.EqualTo("account_type", "com.ohos.contacts");
593 predicates.And();
594 predicates.EqualTo("account_name", "phone");
595 }
596 return predicates;
597 }
598
599 /**
600 * @brief Resolve object interface in IS_MY_CARD case
601 *
602 * @param env Conditions for resolve object interface operation
603 * @param id Conditions for resolve object interface operation
604 */
BuildIsMyCardPredicates(napi_env env,napi_value id)605 DataShare::DataSharePredicates BuildIsMyCardPredicates(napi_env env, napi_value id)
606 {
607 ContactsBuild contactsBuild;
608 int value = contactsBuild.GetInt(env, id);
609 DataShare::DataSharePredicates predicates;
610 if (value != 0) {
611 predicates.EqualTo("is_deleted", "0");
612 predicates.And();
613 predicates.EqualTo("contact_id", std::to_string(value));
614 }
615 return predicates;
616 }
617
ExecuteDone(napi_env env,napi_status status,void * data)618 void ExecuteDone(napi_env env, napi_status status, void *data)
619 {
620 HILOG_INFO("contactApi ExecuteDone start===>");
621 ExecuteHelper *executeHelper = reinterpret_cast<ExecuteHelper *>(data);
622 HILOG_INFO("ExecuteDone workName: %{public}d", executeHelper->actionCode);
623 napi_value result = nullptr;
624 napi_deferred deferred = executeHelper->deferred;
625 HandleExecuteResult(env, executeHelper, result);
626 if (executeHelper->abilityContext != nullptr) {
627 HILOG_INFO("executeHelper->abilityContext != nullptr");
628 napi_value errorCode = nullptr;
629 HandleExecuteErrorCode(env, executeHelper, errorCode);
630 if (errorCode != nullptr) {
631 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, errorCode));
632 } else {
633 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
634 }
635 } else {
636 HILOG_INFO("executeHelper->abilityContext = nullptr");
637 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
638 }
639 executeHelper->deferred = nullptr;
640 if (executeHelper->valueUpdateContact.capacity() != 0) {
641 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
642 }
643 if (executeHelper->valueContact.capacity() != 0) {
644 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
645 }
646 if (executeHelper->valueContactData.capacity() != 0) {
647 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
648 }
649
650 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, executeHelper->work));
651 if (executeHelper->dataShareHelper != nullptr) {
652 executeHelper->dataShareHelper->Release();
653 executeHelper->dataShareHelper = nullptr;
654 }
655 delete executeHelper;
656 executeHelper = nullptr;
657 }
658
ExecuteSyncDone(napi_env env,napi_status status,void * data)659 void ExecuteSyncDone(napi_env env, napi_status status, void *data)
660 {
661 HILOG_INFO("contactApi ExecuteSyncDone start===>");
662 if (status != napi_ok) {
663 HILOG_ERROR("ExecuteSyncDone status is not ok===>");
664 return;
665 }
666 if (data != nullptr) {
667 ExecuteHelper *executeHelper = reinterpret_cast<ExecuteHelper *>(data);
668 HILOG_INFO("ExecuteSyncDone workName: %{public}d", executeHelper->actionCode);
669 napi_value global;
670 napi_get_global(env, &global);
671 napi_value resultData[RESULT_DATA_SIZE];
672 if (executeHelper->abilityContext != nullptr) {
673 HandleExecuteErrorCode(env, executeHelper, resultData[0]);
674 HandleExecuteResult(env, executeHelper, resultData[1]);
675 } else {
676 if (executeHelper->resultData < 0) {
677 HandleExecuteResult(env, executeHelper, resultData[0]);
678 napi_get_undefined(env, &resultData[1]);
679 } else {
680 napi_get_undefined(env, &resultData[0]);
681 HandleExecuteResult(env, executeHelper, resultData[1]);
682 }
683 }
684
685 napi_value result;
686 napi_value callBack;
687 napi_get_reference_value(env, executeHelper->callBack, &callBack);
688 napi_valuetype valuetype = napi_undefined;
689 napi_typeof(env, callBack, &valuetype);
690 if (valuetype != napi_function) {
691 HILOG_ERROR("contactApi params not is function");
692 return;
693 }
694 napi_call_function(env, global, callBack, RESULT_DATA_SIZE, resultData, &result);
695 if (executeHelper->work != nullptr) {
696 napi_delete_async_work(env, executeHelper->work);
697 }
698 executeHelper->work = nullptr;
699 executeHelper->deferred = nullptr;
700 if (executeHelper->valueUpdateContact.capacity() != 0) {
701 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
702 }
703 if (executeHelper->valueContact.capacity() != 0) {
704 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
705 }
706 if (executeHelper->valueContactData.capacity() != 0) {
707 std::vector<DataShare::DataShareValuesBucket>().swap(executeHelper->valueUpdateContact);
708 }
709 if (executeHelper->dataShareHelper != nullptr) {
710 executeHelper->dataShareHelper->Release();
711 executeHelper->dataShareHelper = nullptr;
712 }
713 delete executeHelper;
714 executeHelper = nullptr;
715 }
716 HILOG_INFO("contactApi ExecuteSyncDone done===>");
717 }
718
HandleExecuteErrorCode(napi_env env,ExecuteHelper * executeHelper,napi_value & result)719 void HandleExecuteErrorCode(napi_env env, ExecuteHelper *executeHelper, napi_value &result)
720 {
721 HILOG_INFO("HandleExecuteErrorCode");
722 ResultConvert resultConvert;
723 switch (executeHelper->actionCode) {
724 case ADD_CONTACT:
725 case DELETE_CONTACT:
726 case UPDATE_CONTACT:
727 case SELECT_CONTACT:
728 case IS_LOCAL_CONTACT:
729 case IS_MY_CARD:
730 if (executeHelper->resultData == RDB_PERMISSION_ERROR) {
731 HILOG_ERROR("permission error");
732 result = ContactsNapiUtils::CreateError(env, PERMISSION_ERROR);
733 }
734 break;
735 case QUERY_CONTACT:
736 case QUERY_MY_CARD:
737 case QUERY_KEY:
738 case QUERY_CONTACTS:
739 case QUERY_CONTACTS_BY_EMAIL:
740 case QUERY_CONTACTS_BY_PHONE_NUMBER:
741 case QUERY_GROUPS:
742 case QUERY_HOLDERS:
743 if (executeHelper->resultSet == nullptr) {
744 HILOG_ERROR("permission error");
745 result = ContactsNapiUtils::CreateError(env, PERMISSION_ERROR);
746 }
747 break;
748 default:
749 break;
750 }
751 }
752
HandleExecuteResult(napi_env env,ExecuteHelper * executeHelper,napi_value & result)753 void HandleExecuteResult(napi_env env, ExecuteHelper *executeHelper, napi_value &result)
754 {
755 ResultConvert resultConvert;
756 napi_value results = nullptr;
757 switch (executeHelper->actionCode) {
758 case ADD_CONTACT:
759 case DELETE_CONTACT:
760 case UPDATE_CONTACT:
761 case SELECT_CONTACT:
762 if (executeHelper->resultData == RDB_PERMISSION_ERROR) {
763 napi_create_int64(env, ERROR, &result);
764 } else {
765 napi_create_int64(env, executeHelper->resultData, &result);
766 }
767 break;
768 case IS_LOCAL_CONTACT:
769 case IS_MY_CARD:
770 napi_get_boolean(env, executeHelper->resultData != 0, &result);
771 break;
772 case QUERY_CONTACT:
773 case QUERY_MY_CARD:
774 results = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
775 if (results != nullptr) {
776 napi_get_element(env, results, 0, &result);
777 }
778 break;
779 case QUERY_KEY:
780 results = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
781 if (results != nullptr) {
782 napi_get_element(env, results, 0, &result);
783 }
784 napi_get_named_property(env, result, "key", &result);
785 break;
786 case QUERY_CONTACTS:
787 case QUERY_CONTACTS_BY_EMAIL:
788 case QUERY_CONTACTS_BY_PHONE_NUMBER:
789 result = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
790 break;
791 case QUERY_GROUPS:
792 result = resultConvert.ResultSetToGroup(env, executeHelper->resultSet);
793 break;
794 case QUERY_HOLDERS:
795 result = resultConvert.ResultSetToHolder(env, executeHelper->resultSet);
796 break;
797 default:
798 break;
799 }
800 }
801
LocalExecuteAddContact(napi_env env,ExecuteHelper * executeHelper)802 void LocalExecuteAddContact(napi_env env, ExecuteHelper *executeHelper)
803 {
804 ContactsControl contactsControl;
805 int rawId = contactsControl.RawContactInsert(
806 executeHelper->dataShareHelper, (executeHelper->valueContact)[0]);
807 std::vector<DataShare::DataShareValuesBucket> value = executeHelper->valueContactData;
808 unsigned int size = value.size();
809 for (unsigned int i = 0; i < size; ++i) {
810 (executeHelper->valueContactData)[i].Put("raw_contact_id", rawId);
811 }
812 int code = contactsControl.ContactDataInsert(executeHelper->dataShareHelper, executeHelper->valueContactData);
813 if (code == 0) {
814 executeHelper->resultData = rawId;
815 } else {
816 executeHelper->resultData = code;
817 }
818 }
819
LocalExecuteDeleteContact(napi_env env,ExecuteHelper * executeHelper)820 void LocalExecuteDeleteContact(napi_env env, ExecuteHelper *executeHelper)
821 {
822 ContactsControl contactsControl;
823 int ret = contactsControl.ContactDelete(executeHelper->dataShareHelper, executeHelper->predicates);
824 HILOG_INFO("LocalExecuteDeleteContact contact ret = %{public}d", ret);
825 executeHelper->resultData = ret;
826 }
827
LocalExecuteQueryContact(napi_env env,ExecuteHelper * executeHelper)828 void LocalExecuteQueryContact(napi_env env, ExecuteHelper *executeHelper)
829 {
830 ContactsControl contactsControl;
831 executeHelper->resultSet = contactsControl.ContactQuery(
832 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
833 executeHelper->resultData = SUCCESS;
834 }
835
LocalExecuteQueryContactsOrKey(napi_env env,ExecuteHelper * executeHelper)836 void LocalExecuteQueryContactsOrKey(napi_env env, ExecuteHelper *executeHelper)
837 {
838 ContactsControl contactsControl;
839 executeHelper->resultSet = contactsControl.ContactQuery(
840 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
841 executeHelper->resultData = SUCCESS;
842 }
843
LocalExecuteQueryContactsByData(napi_env env,ExecuteHelper * executeHelper)844 void LocalExecuteQueryContactsByData(napi_env env, ExecuteHelper *executeHelper)
845 {
846 ContactsControl contactsControl;
847 executeHelper->resultSet = contactsControl.ContactDataQuery(
848 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
849 executeHelper->resultData = SUCCESS;
850 }
851
LocalExecuteQueryGroup(napi_env env,ExecuteHelper * executeHelper)852 void LocalExecuteQueryGroup(napi_env env, ExecuteHelper *executeHelper)
853 {
854 ContactsControl contactsControl;
855 executeHelper->resultSet = contactsControl.GroupsQuery(
856 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
857 executeHelper->resultData = SUCCESS;
858 }
859
LocalExecuteQueryHolders(napi_env env,ExecuteHelper * executeHelper)860 void LocalExecuteQueryHolders(napi_env env, ExecuteHelper *executeHelper)
861 {
862 ContactsControl contactsControl;
863 executeHelper->resultSet = contactsControl.HolderQuery(
864 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
865 executeHelper->resultData = SUCCESS;
866 }
867
LocalExecuteQueryMyCard(napi_env env,ExecuteHelper * executeHelper)868 void LocalExecuteQueryMyCard(napi_env env, ExecuteHelper *executeHelper)
869 {
870 ContactsControl contactsControl;
871 executeHelper->resultSet = contactsControl.MyCardQuery(
872 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
873 executeHelper->resultData = SUCCESS;
874 }
875
LocalExecuteUpdateContact(napi_env env,ExecuteHelper * executeHelper)876 void LocalExecuteUpdateContact(napi_env env, ExecuteHelper *executeHelper)
877 {
878 ContactsControl contactsControl;
879 // query raw_contact_id
880 std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.ContactDataQuery(
881 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
882 int rawId = GetRawIdByResultSet(resultSet);
883 if (rawId == 0) {
884 HILOG_ERROR("LocalExecuteUpdateContact contact rawId equals 0");
885 executeHelper->resultData = ERROR;
886 return;
887 }
888 std::vector<DataShare::DataShareValuesBucket> value = executeHelper->valueContactData;
889 unsigned int size = value.size();
890 for (unsigned int i = 0; i < size; ++i) {
891 (executeHelper->valueContactData)[i].Put("raw_contact_id", rawId);
892 }
893 executeHelper->deletePredicates.And();
894 executeHelper->deletePredicates.EqualTo("raw_contact_id", std::to_string(rawId));
895 int resultCode = contactsControl.ContactDataDelete(
896 executeHelper->dataShareHelper, executeHelper->deletePredicates);
897 if (resultCode >= 0) {
898 resultCode = contactsControl.ContactDataInsert(
899 executeHelper->dataShareHelper, executeHelper->valueContactData);
900 }
901 executeHelper->resultData = resultCode;
902 }
903
LocalExecuteIsLocalContact(napi_env env,ExecuteHelper * executeHelper)904 void LocalExecuteIsLocalContact(napi_env env, ExecuteHelper *executeHelper)
905 {
906 int64_t isLocal = 0;
907 ContactsControl contactsControl;
908 std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.ContactQuery(
909 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
910 if (resultSet == nullptr) {
911 executeHelper->resultData = isLocal;
912 return;
913 }
914 int resultSetNum = resultSet->GoToFirstRow();
915 if (resultSetNum == OHOS::NativeRdb::E_OK) {
916 isLocal = 1;
917 }
918 executeHelper->resultData = isLocal;
919 resultSet->Close();
920 }
921
LocalExecuteIsMyCard(napi_env env,ExecuteHelper * executeHelper)922 void LocalExecuteIsMyCard(napi_env env, ExecuteHelper *executeHelper)
923 {
924 int64_t isMyCard = 0;
925 ContactsControl contactsControl;
926 std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.MyCardQuery(
927 executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
928 if (resultSet == nullptr) {
929 executeHelper->resultData = isMyCard;
930 return;
931 }
932 int rowCount = 0;
933 resultSet->GetRowCount(rowCount);
934 int resultSetNum = resultSet->GoToFirstRow();
935 if (resultSetNum == OHOS::NativeRdb::E_OK) {
936 isMyCard = 1;
937 }
938 executeHelper->resultData = isMyCard;
939 resultSet->Close();
940 }
941
LocalExecute(napi_env env,ExecuteHelper * executeHelper)942 void LocalExecute(napi_env env, ExecuteHelper *executeHelper)
943 {
944 if (executeHelper->dataShareHelper == nullptr) {
945 HILOG_ERROR("create dataShareHelper is null, please check your permission");
946 executeHelper->resultData = RDB_PERMISSION_ERROR;
947 return;
948 }
949 switch (executeHelper->actionCode) {
950 case ADD_CONTACT:
951 LocalExecuteAddContact(env, executeHelper);
952 break;
953 case DELETE_CONTACT:
954 LocalExecuteDeleteContact(env, executeHelper);
955 break;
956 case QUERY_CONTACT:
957 LocalExecuteQueryContact(env, executeHelper);
958 break;
959 case QUERY_CONTACTS:
960 LocalExecuteQueryContactsOrKey(env, executeHelper);
961 break;
962 case QUERY_CONTACTS_BY_EMAIL:
963 case QUERY_CONTACTS_BY_PHONE_NUMBER:
964 LocalExecuteQueryContactsByData(env, executeHelper);
965 break;
966 case QUERY_GROUPS:
967 LocalExecuteQueryGroup(env, executeHelper);
968 break;
969 case QUERY_HOLDERS:
970 LocalExecuteQueryHolders(env, executeHelper);
971 break;
972 case QUERY_KEY:
973 LocalExecuteQueryContactsOrKey(env, executeHelper);
974 break;
975 case QUERY_MY_CARD:
976 LocalExecuteQueryMyCard(env, executeHelper);
977 break;
978 case UPDATE_CONTACT:
979 LocalExecuteUpdateContact(env, executeHelper);
980 break;
981 case IS_LOCAL_CONTACT:
982 LocalExecuteIsLocalContact(env, executeHelper);
983 break;
984 case IS_MY_CARD:
985 LocalExecuteIsMyCard(env, executeHelper);
986 break;
987 default:
988 HILOG_INFO("LocalExecute case error===>");
989 break;
990 }
991 }
992
Execute(napi_env env,void * data)993 void Execute(napi_env env, void *data)
994 {
995 ExecuteHelper *executeHelper = static_cast<ExecuteHelper *>(data);
996 HILOG_INFO("Execute start workName: %{public}d", executeHelper->actionCode);
997 LocalExecute(env, executeHelper);
998 }
999
CreateAsyncWork(napi_env env,ExecuteHelper * executeHelper)1000 napi_value CreateAsyncWork(napi_env env, ExecuteHelper *executeHelper)
1001 {
1002 napi_value workName;
1003 napi_value result = nullptr;
1004 if (executeHelper->sync == NAPI_CALL_TYPE_CALLBACK) {
1005 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &workName);
1006 napi_create_reference(env, executeHelper->argv[executeHelper->argc - 1], 1, &executeHelper->callBack);
1007 napi_create_async_work(env, nullptr, workName, Execute, ExecuteSyncDone,
1008 reinterpret_cast<void *>(executeHelper), &(executeHelper->work));
1009 napi_get_null(env, &result);
1010 } else {
1011 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &workName);
1012 napi_create_promise(env, &(executeHelper->deferred), &result);
1013 napi_create_async_work(env, nullptr, workName, Execute, ExecuteDone,
1014 reinterpret_cast<void *>(executeHelper), &(executeHelper->work));
1015 }
1016 napi_queue_async_work(env, executeHelper->work);
1017 executeHelper->promise = result;
1018 return result;
1019 }
1020
ConvertParamsSwitchSplit(int code,napi_env env,const napi_value & key,const napi_value & hold,const napi_value & attr)1021 DataShare::DataSharePredicates ConvertParamsSwitchSplit(
1022 int code, napi_env env, const napi_value &key, const napi_value &hold, const napi_value &attr)
1023 {
1024 DataShare::DataSharePredicates predicates;
1025 switch (code) {
1026 case QUERY_CONTACT:
1027 predicates = BuildQueryContactPredicates(env, key, hold, attr);
1028 break;
1029 case QUERY_CONTACTS:
1030 predicates = BuildQueryContactsPredicates(env, hold, attr);
1031 break;
1032 case QUERY_CONTACTS_BY_EMAIL:
1033 predicates = BuildQueryContactsByEmailPredicates(env, key, hold, attr);
1034 break;
1035 case QUERY_CONTACTS_BY_PHONE_NUMBER:
1036 predicates = BuildQueryContactsByPhoneNumberPredicates(env, key, hold, attr);
1037 break;
1038 case QUERY_GROUPS:
1039 predicates = BuildQueryGroupsPredicates(env, hold);
1040 break;
1041 case QUERY_HOLDERS:
1042 break;
1043 case QUERY_MY_CARD:
1044 predicates = BuildQueryMyCardPredicates(env, attr);
1045 break;
1046 default:
1047 HILOG_ERROR("ConvertParamsSwitchSplit code is no match");
1048 break;
1049 }
1050 return predicates;
1051 }
1052
SetChildActionCodeAndConvertParams(napi_env env,ExecuteHelper * executeHelper)1053 void SetChildActionCodeAndConvertParams(napi_env env, ExecuteHelper *executeHelper)
1054 {
1055 napi_value id = nullptr;
1056 napi_value key = nullptr;
1057 napi_value hold = nullptr;
1058 napi_value attr = nullptr;
1059 napi_value contact = nullptr;
1060 unsigned int size = executeHelper->argc;
1061 for (unsigned int i = 0; i < size; i++) {
1062 ObjectInitId(env, executeHelper->argv[i], id);
1063 ObjectInitString(env, executeHelper->argv[i], key);
1064 ObjectInit(env, executeHelper->argv[i], hold, attr, contact);
1065 }
1066 ContactsBuild contactsBuild;
1067 switch (executeHelper->actionCode) {
1068 case ADD_CONTACT:
1069 contactsBuild.GetContactData(
1070 env, executeHelper->argv[0], executeHelper->valueContact, executeHelper->valueContactData);
1071 break;
1072 case DELETE_CONTACT:
1073 executeHelper->predicates = BuildDeleteContactPredicates(env, executeHelper);
1074 break;
1075 case UPDATE_CONTACT:
1076 executeHelper->predicates = BuildUpdateContactConvertParams(env, contact, attr, executeHelper);
1077 break;
1078 case IS_LOCAL_CONTACT:
1079 executeHelper->predicates = BuildIsLocalContactPredicates(env, id);
1080 break;
1081 case IS_MY_CARD:
1082 executeHelper->predicates = BuildIsMyCardPredicates(env, id);
1083 break;
1084 case QUERY_KEY:
1085 executeHelper->predicates = BuildQueryKeyPredicates(env, id, hold);
1086 break;
1087 default:
1088 executeHelper->predicates = ConvertParamsSwitchSplit(executeHelper->actionCode, env, key, hold, attr);
1089 break;
1090 }
1091 }
1092
Scheduling(napi_env env,napi_callback_info info,ExecuteHelper * executeHelper,int actionCode)1093 napi_value Scheduling(napi_env env, napi_callback_info info, ExecuteHelper *executeHelper, int actionCode)
1094 {
1095 size_t argc = MAX_PARAMS;
1096 napi_value argv[MAX_PARAMS] = {0};
1097 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1098 executeHelper->argc = argc;
1099 executeHelper->actionCode = actionCode;
1100
1101 if (argc > 0) {
1102 napi_valuetype valuetype = napi_undefined;
1103 napi_typeof(env, argv[argc - 1], &valuetype);
1104 // last params is function as callback
1105 if (valuetype == napi_function) {
1106 executeHelper->sync = NAPI_CALL_TYPE_CALLBACK;
1107 } else {
1108 executeHelper->sync = NAPI_CALL_TYPE_PROMISE;
1109 }
1110 }
1111 bool isStageMode = false;
1112 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1113 if (isStageMode) {
1114 HILOG_INFO("use API 10 interface");
1115 for (int i = 1; i < MAX_PARAMS; i++) {
1116 executeHelper->argv[i - 1] = argv[i];
1117 }
1118 executeHelper->abilityContext = argv[0];
1119 executeHelper->argc -= 1;
1120 } else {
1121 HILOG_INFO("use API 7 interface");
1122 for (int i = 0; i < MAX_PARAMS; i++) {
1123 executeHelper->argv[i] = argv[i];
1124 }
1125 }
1126
1127 SetChildActionCodeAndConvertParams(env, executeHelper);
1128 GetDataShareHelper(env, info, executeHelper);
1129
1130 napi_value result = CreateAsyncWork(env, executeHelper);
1131 return result;
1132 }
1133
1134 /**
1135 * @brief Test interface ADD_CONTACT
1136 *
1137 * @param env Conditions for resolve object interface operation
1138 * @param info Conditions for resolve object interface operation
1139 *
1140 * @return The result returned by test
1141 */
AddContact(napi_env env,napi_callback_info info)1142 napi_value AddContact(napi_env env, napi_callback_info info)
1143 {
1144 size_t argc = MAX_PARAMS;
1145 napi_value argv[MAX_PARAMS] = {0};
1146 napi_value thisVar = nullptr;
1147 void *data;
1148 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1149 bool isStageMode = false;
1150 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1151 if (isStageMode) {
1152 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1153 switch (argc) {
1154 case ARGS_TWO:
1155 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object })) {
1156 napi_throw(env, errorCode);
1157 }
1158 break;
1159 case ARGS_THREE:
1160 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_function })) {
1161 napi_throw(env, errorCode);
1162 }
1163 break;
1164 default:
1165 napi_throw(env, errorCode);
1166 break;
1167 }
1168 }
1169 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1170 napi_value result = nullptr;
1171 if (executeHelper != nullptr) {
1172 result = Scheduling(env, info, executeHelper, ADD_CONTACT);
1173 return result;
1174 }
1175 napi_create_int64(env, ERROR, &result);
1176 return result;
1177 }
1178
1179 /**
1180 * @brief Test interface DELETE_CONTACT
1181 *
1182 * @param env Conditions for resolve object interface operation
1183 * @param info Conditions for resolve object interface operation
1184 *
1185 * @return The result returned by test
1186 */
DeleteContact(napi_env env,napi_callback_info info)1187 napi_value DeleteContact(napi_env env, napi_callback_info info)
1188 {
1189 size_t argc = MAX_PARAMS;
1190 napi_value argv[MAX_PARAMS] = {0};
1191 napi_value thisVar = nullptr;
1192 void *data;
1193 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1194 bool isStageMode = false;
1195 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1196 if (isStageMode) {
1197 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1198 switch (argc) {
1199 case ARGS_TWO:
1200 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string })) {
1201 napi_throw(env, errorCode);
1202 }
1203 break;
1204 case ARGS_THREE:
1205 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string, napi_function })) {
1206 napi_throw(env, errorCode);
1207 }
1208 break;
1209 default:
1210 napi_throw(env, errorCode);
1211 break;
1212 }
1213 }
1214 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1215 napi_value result = nullptr;
1216 if (executeHelper != nullptr) {
1217 result = Scheduling(env, info, executeHelper, DELETE_CONTACT);
1218 return result;
1219 }
1220 napi_create_int64(env, ERROR, &result);
1221 return result;
1222 }
1223
1224 /**
1225 * @brief Test interface UPDATE_CONTACT
1226 *
1227 * @param env Conditions for resolve object interface operation
1228 * @param info Conditions for resolve object interface operation
1229 *
1230 * @return The result returned by test
1231 */
UpdateContact(napi_env env,napi_callback_info info)1232 napi_value UpdateContact(napi_env env, napi_callback_info info)
1233 {
1234 size_t argc = MAX_PARAMS;
1235 napi_value argv[MAX_PARAMS] = {0};
1236 napi_value thisVar = nullptr;
1237 void *data;
1238 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1239 bool isStageMode = false;
1240 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1241 if (isStageMode) {
1242 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1243 switch (argc) {
1244 case ARGS_TWO:
1245 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object })) {
1246 napi_throw(env, errorCode);
1247 }
1248 break;
1249 case ARGS_THREE:
1250 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_function })
1251 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_object })) {
1252 napi_throw(env, errorCode);
1253 }
1254 break;
1255 case ARGS_FOUR:
1256 if (!ContactsNapiUtils::MatchParameters(env, argv,
1257 { napi_object, napi_object, napi_object, napi_function })) {
1258 napi_throw(env, errorCode);
1259 }
1260 break;
1261 default:
1262 napi_throw(env, errorCode);
1263 break;
1264 }
1265 }
1266 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1267 napi_value result = nullptr;
1268 if (executeHelper != nullptr) {
1269 result = Scheduling(env, info, executeHelper, UPDATE_CONTACT);
1270 return result;
1271 }
1272 napi_create_int64(env, ERROR, &result);
1273 return result;
1274 }
1275
1276 /**
1277 * @brief Test interface QUERY_CONTACT
1278 *
1279 * @param env Conditions for resolve object interface operation
1280 * @param info Conditions for resolve object interface operation
1281 *
1282 * @return The result returned by test
1283 */
QueryContact(napi_env env,napi_callback_info info)1284 napi_value QueryContact(napi_env env, napi_callback_info info)
1285 {
1286 size_t argc = MAX_PARAMS;
1287 napi_value argv[MAX_PARAMS] = {0};
1288 napi_value thisVar = nullptr;
1289 void *data;
1290 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1291 bool isStageMode = false;
1292 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1293 if (isStageMode) {
1294 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1295 switch (argc) {
1296 case ARGS_TWO:
1297 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string })) {
1298 napi_throw(env, errorCode);
1299 }
1300 break;
1301 case ARGS_THREE:
1302 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string, napi_function })) {
1303 napi_throw(env, errorCode);
1304 }
1305 break;
1306 case ARGS_FOUR:
1307 if (!ContactsNapiUtils::MatchParameters(env, argv,
1308 { napi_object, napi_string, napi_object, napi_function }) &&
1309 !ContactsNapiUtils::MatchParameters(env, argv,
1310 { napi_object, napi_string, napi_object, napi_object })) {
1311 napi_throw(env, errorCode);
1312 }
1313 break;
1314 case ARGS_FIVE:
1315 if (!ContactsNapiUtils::MatchParameters(env, argv,
1316 {
1317 napi_object, napi_string, napi_object, napi_object, napi_function
1318 })) {
1319 napi_throw(env, errorCode);
1320 }
1321 break;
1322 default:
1323 napi_throw(env, errorCode);
1324 break;
1325 }
1326 }
1327 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1328 napi_value result = nullptr;
1329 if (executeHelper != nullptr) {
1330 result = Scheduling(env, info, executeHelper, QUERY_CONTACT);
1331 return result;
1332 }
1333 napi_create_int64(env, ERROR, &result);
1334 return result;
1335 }
1336
1337 /**
1338 * @brief Test interface QUERY_CONTACTS
1339 *
1340 * @param env Conditions for resolve object interface operation
1341 * @param info Conditions for resolve object interface operation
1342 *
1343 * @return The result returned by test
1344 */
QueryContacts(napi_env env,napi_callback_info info)1345 napi_value QueryContacts(napi_env env, napi_callback_info info)
1346 {
1347 size_t argc = MAX_PARAMS;
1348 napi_value argv[MAX_PARAMS] = {0};
1349 napi_value thisVar = nullptr;
1350 void *data;
1351 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1352 bool isStageMode = false;
1353 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1354 if (isStageMode) {
1355 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1356 switch (argc) {
1357 case ARGS_ONE:
1358 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object })) {
1359 napi_throw(env, errorCode);
1360 }
1361 break;
1362 case ARGS_TWO:
1363 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_function })) {
1364 napi_throw(env, errorCode);
1365 }
1366 break;
1367 case ARGS_THREE:
1368 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_function })
1369 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_object })
1370 ) {
1371 napi_throw(env, errorCode);
1372 }
1373 break;
1374 case ARGS_FOUR:
1375 if (!ContactsNapiUtils::MatchParameters(env, argv,
1376 { napi_object, napi_object, napi_object, napi_function })) {
1377 napi_throw(env, errorCode);
1378 }
1379 break;
1380 default:
1381 napi_throw(env, errorCode);
1382 break;
1383 }
1384 }
1385 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1386 napi_value result = nullptr;
1387 if (executeHelper != nullptr) {
1388 result = Scheduling(env, info, executeHelper, QUERY_CONTACTS);
1389 return result;
1390 }
1391 napi_create_int64(env, ERROR, &result);
1392 return result;
1393 }
1394
1395 /**
1396 * @brief Test interface QUERY_CONTACTS_BY_EMAIL
1397 *
1398 * @param env Conditions for resolve object interface operation
1399 * @param info Conditions for resolve object interface operation
1400 *
1401 * @return The result returned by test
1402 */
QueryContactsByEmail(napi_env env,napi_callback_info info)1403 napi_value QueryContactsByEmail(napi_env env, napi_callback_info info)
1404 {
1405 size_t argc = MAX_PARAMS;
1406 napi_value argv[MAX_PARAMS] = {0};
1407 napi_value thisVar = nullptr;
1408 void *data;
1409 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1410 bool isStageMode = false;
1411 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1412 if (isStageMode) {
1413 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1414 switch (argc) {
1415 case ARGS_TWO:
1416 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string })) {
1417 napi_throw(env, errorCode);
1418 }
1419 break;
1420 case ARGS_THREE:
1421 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string, napi_function })) {
1422 napi_throw(env, errorCode);
1423 }
1424 break;
1425 case ARGS_FOUR:
1426 if (!ContactsNapiUtils::MatchParameters(env, argv,
1427 { napi_object, napi_string, napi_object, napi_function }) &&
1428 !ContactsNapiUtils::MatchParameters(env, argv,
1429 { napi_object, napi_string, napi_object, napi_function }) &&
1430 !ContactsNapiUtils::MatchParameters(env, argv,
1431 { napi_object, napi_string, napi_object, napi_object })) {
1432 napi_throw(env, errorCode);
1433 }
1434 break;
1435 case ARGS_FIVE:
1436 if (!ContactsNapiUtils::MatchParameters(env, argv,
1437 {
1438 napi_object, napi_string, napi_object, napi_object, napi_function
1439 })) {
1440 napi_throw(env, errorCode);
1441 }
1442 break;
1443 default:
1444 napi_throw(env, errorCode);
1445 break;
1446 }
1447 }
1448 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1449 napi_value result = nullptr;
1450 if (executeHelper != nullptr) {
1451 result = Scheduling(env, info, executeHelper, QUERY_CONTACTS_BY_EMAIL);
1452 return result;
1453 }
1454 napi_create_int64(env, ERROR, &result);
1455 return result;
1456 }
1457
1458 /**
1459 * @brief Test interface QUERY_CONTACTS_BY_PHONE_NUMBER
1460 *
1461 * @param env Conditions for resolve object interface operation
1462 * @param info Conditions for resolve object interface operation
1463 *
1464 * @return The result returned by test
1465 */
QueryContactsByPhoneNumber(napi_env env,napi_callback_info info)1466 napi_value QueryContactsByPhoneNumber(napi_env env, napi_callback_info info)
1467 {
1468 size_t argc = MAX_PARAMS;
1469 napi_value argv[MAX_PARAMS] = {0};
1470 napi_value thisVar = nullptr;
1471 void *data;
1472 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1473 bool isStageMode = false;
1474 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1475 if (isStageMode) {
1476 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1477 switch (argc) {
1478 case ARGS_TWO:
1479 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string })) {
1480 napi_throw(env, errorCode);
1481 }
1482 break;
1483 case ARGS_THREE:
1484 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_string, napi_function })) {
1485 napi_throw(env, errorCode);
1486 }
1487 break;
1488 case ARGS_FOUR:
1489 if (!ContactsNapiUtils::MatchParameters(env, argv,
1490 { napi_object, napi_string, napi_object, napi_function }) &&
1491 !ContactsNapiUtils::MatchParameters(env, argv,
1492 { napi_object, napi_string, napi_object, napi_object })) {
1493 napi_throw(env, errorCode);
1494 }
1495 break;
1496 case ARGS_FIVE:
1497 if (!ContactsNapiUtils::MatchParameters(env, argv,
1498 {
1499 napi_object, napi_string, napi_object, napi_object, napi_function
1500 })) {
1501 napi_throw(env, errorCode);
1502 }
1503 break;
1504 default:
1505 napi_throw(env, errorCode);
1506 break;
1507 }
1508 }
1509 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1510 napi_value result = nullptr;
1511 if (executeHelper != nullptr) {
1512 result = Scheduling(env, info, executeHelper, QUERY_CONTACTS_BY_PHONE_NUMBER);
1513 return result;
1514 }
1515 napi_create_int64(env, ERROR, &result);
1516 return result;
1517 }
1518
1519 /**
1520 * @brief Test interface QUERY_CONTACTS_BY_PHONE_NUMBER
1521 *
1522 * @param env Conditions for resolve object interface operation
1523 * @param info Conditions for resolve object interface operation
1524 *
1525 * @return The result returned by test
1526 */
QueryGroups(napi_env env,napi_callback_info info)1527 napi_value QueryGroups(napi_env env, napi_callback_info info)
1528 {
1529 size_t argc = MAX_PARAMS;
1530 napi_value argv[MAX_PARAMS] = {0};
1531 napi_value thisVar = nullptr;
1532 void *data;
1533 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1534 bool isStageMode = false;
1535 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1536 if (isStageMode) {
1537 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1538 switch (argc) {
1539 case ARGS_ONE:
1540 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object })) {
1541 napi_throw(env, errorCode);
1542 }
1543 break;
1544 case ARGS_TWO:
1545 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_function })
1546 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object })) {
1547 napi_throw(env, errorCode);
1548 }
1549 break;
1550 case ARGS_THREE:
1551 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_function })) {
1552 napi_throw(env, errorCode);
1553 }
1554 break;
1555 default:
1556 napi_throw(env, errorCode);
1557 break;
1558 }
1559 }
1560 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1561 napi_value result = nullptr;
1562 if (executeHelper != nullptr) {
1563 result = Scheduling(env, info, executeHelper, QUERY_GROUPS);
1564 return result;
1565 }
1566 napi_create_int64(env, ERROR, &result);
1567 return result;
1568 }
1569
1570 /**
1571 * @brief Test interface QUERY_HOLDERS
1572 *
1573 * @param env Conditions for resolve object interface operation
1574 * @param info Conditions for resolve object interface operation
1575 *
1576 * @return The result returned by test
1577 */
QueryHolders(napi_env env,napi_callback_info info)1578 napi_value QueryHolders(napi_env env, napi_callback_info info)
1579 {
1580 size_t argc = MAX_PARAMS;
1581 napi_value argv[MAX_PARAMS] = {0};
1582 napi_value thisVar = nullptr;
1583 void *data;
1584 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1585 bool isStageMode = false;
1586 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1587 if (isStageMode) {
1588 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1589 switch (argc) {
1590 case ARGS_ONE:
1591 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object })) {
1592 napi_throw(env, errorCode);
1593 }
1594 break;
1595 case ARGS_TWO:
1596 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_function })) {
1597 napi_throw(env, errorCode);
1598 }
1599 break;
1600 default:
1601 napi_throw(env, errorCode);
1602 break;
1603 }
1604 }
1605 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1606 napi_value result = nullptr;
1607 if (executeHelper != nullptr) {
1608 result = Scheduling(env, info, executeHelper, QUERY_HOLDERS);
1609 return result;
1610 }
1611 napi_create_int64(env, ERROR, &result);
1612 return result;
1613 }
1614
1615 /**
1616 * @brief Test interface QUERY_KEY
1617 *
1618 * @param env Conditions for resolve object interface operation
1619 * @param info Conditions for resolve object interface operation
1620 *
1621 * @return The result returned by test
1622 */
QueryKey(napi_env env,napi_callback_info info)1623 napi_value QueryKey(napi_env env, napi_callback_info info)
1624 {
1625 size_t argc = MAX_PARAMS;
1626 napi_value argv[MAX_PARAMS] = {0};
1627 napi_value thisVar = nullptr;
1628 void *data;
1629 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1630 bool isStageMode = false;
1631 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1632 if (isStageMode) {
1633 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1634 switch (argc) {
1635 case ARGS_ONE:
1636 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object })) {
1637 napi_throw(env, errorCode);
1638 }
1639 break;
1640 case ARGS_TWO:
1641 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_function })
1642 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number })) {
1643 napi_throw(env, errorCode);
1644 }
1645 break;
1646 case ARGS_THREE:
1647 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number, napi_function })
1648 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number, napi_object })) {
1649 napi_throw(env, errorCode);
1650 }
1651 break;
1652 case ARGS_FOUR:
1653 if (!ContactsNapiUtils::MatchParameters(env, argv,
1654 { napi_object, napi_number, napi_object, napi_function })) {
1655 napi_throw(env, errorCode);
1656 }
1657 break;
1658 default:
1659 napi_throw(env, errorCode);
1660 break;
1661 }
1662 }
1663 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1664 napi_value result = nullptr;
1665 if (executeHelper != nullptr) {
1666 result = Scheduling(env, info, executeHelper, QUERY_KEY);
1667 return result;
1668 }
1669 napi_create_int64(env, ERROR, &result);
1670 return result;
1671 }
1672
1673 /**
1674 * @brief Test interface QUERY_MY_CARD
1675 *
1676 * @param env Conditions for resolve object interface operation
1677 * @param info Conditions for resolve object interface operation
1678 *
1679 * @return The result returned by test
1680 */
QueryMyCard(napi_env env,napi_callback_info info)1681 napi_value QueryMyCard(napi_env env, napi_callback_info info)
1682 {
1683 size_t argc = MAX_PARAMS;
1684 napi_value argv[MAX_PARAMS] = {0};
1685 napi_value thisVar = nullptr;
1686 void *data;
1687 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1688 bool isStageMode = false;
1689 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1690 if (isStageMode) {
1691 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1692 switch (argc) {
1693 case ARGS_ONE:
1694 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object })) {
1695 napi_throw(env, errorCode);
1696 }
1697 break;
1698 case ARGS_TWO:
1699 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object })
1700 && !ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_function })) {
1701 napi_throw(env, errorCode);
1702 }
1703 break;
1704 case ARGS_THREE:
1705 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_object, napi_function })) {
1706 napi_throw(env, errorCode);
1707 }
1708 break;
1709 default:
1710 napi_throw(env, errorCode);
1711 break;
1712 }
1713 }
1714 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1715 napi_value result = nullptr;
1716 if (executeHelper != nullptr) {
1717 result = Scheduling(env, info, executeHelper, QUERY_MY_CARD);
1718 return result;
1719 }
1720 napi_create_int64(env, ERROR, &result);
1721 return result;
1722 }
1723
1724 /**
1725 * @brief Test interface IS_MY_CARD
1726 *
1727 * @param env Conditions for resolve object interface operation
1728 * @param info Conditions for resolve object interface operation
1729 *
1730 * @return The result returned by test
1731 */
IsMyCard(napi_env env,napi_callback_info info)1732 napi_value IsMyCard(napi_env env, napi_callback_info info)
1733 {
1734 size_t argc = MAX_PARAMS;
1735 napi_value argv[MAX_PARAMS] = {0};
1736 napi_value thisVar = nullptr;
1737 void *data;
1738 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1739 bool isStageMode = false;
1740 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1741 if (isStageMode) {
1742 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1743 switch (argc) {
1744 case ARGS_TWO:
1745 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number })) {
1746 napi_throw(env, errorCode);
1747 }
1748 break;
1749 case ARGS_THREE:
1750 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number, napi_function })) {
1751 napi_throw(env, errorCode);
1752 }
1753 break;
1754 default:
1755 napi_throw(env, errorCode);
1756 break;
1757 }
1758 }
1759 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1760 napi_value result = nullptr;
1761 if (executeHelper != nullptr) {
1762 result = Scheduling(env, info, executeHelper, IS_MY_CARD);
1763 return result;
1764 }
1765 napi_create_int64(env, ERROR, &result);
1766 return result;
1767 }
1768
1769 /**
1770 * @brief Test interface IS_LOCAL_CONTACT
1771 *
1772 * @param env Conditions for resolve object interface operation
1773 * @param info Conditions for resolve object interface operation
1774 *
1775 * @return The result returned by test
1776 */
IsLocalContact(napi_env env,napi_callback_info info)1777 napi_value IsLocalContact(napi_env env, napi_callback_info info)
1778 {
1779 size_t argc = MAX_PARAMS;
1780 napi_value argv[MAX_PARAMS] = {0};
1781 napi_value thisVar = nullptr;
1782 void *data;
1783 napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1784 bool isStageMode = false;
1785 OHOS::AbilityRuntime::IsStageContext(env, argv[0], isStageMode);
1786 if (isStageMode) {
1787 napi_value errorCode = ContactsNapiUtils::CreateError(env, PARAMETER_ERROR);
1788 switch (argc) {
1789 case ARGS_TWO:
1790 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number })) {
1791 napi_throw(env, errorCode);
1792 }
1793 break;
1794 case ARGS_THREE:
1795 if (!ContactsNapiUtils::MatchParameters(env, argv, { napi_object, napi_number, napi_function })) {
1796 napi_throw(env, errorCode);
1797 }
1798 break;
1799 default:
1800 napi_throw(env, errorCode);
1801 break;
1802 }
1803 }
1804 ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1805 napi_value result = nullptr;
1806 if (executeHelper != nullptr) {
1807 result = Scheduling(env, info, executeHelper, IS_LOCAL_CONTACT);
1808 return result;
1809 }
1810 napi_create_int64(env, ERROR, &result);
1811 return result;
1812 }
1813
DeclareContactConst(napi_env env,napi_value exports)1814 napi_value DeclareContactConst(napi_env env, napi_value exports)
1815 {
1816 // Contact
1817 napi_property_descriptor desc[] = {
1818 DECLARE_NAPI_STATIC_PROPERTY("INVALID_CONTACT_ID",
1819 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Contacts::INVALID_CONTACT_ID))),
1820 };
1821 napi_value result = nullptr;
1822 napi_define_class(env, "Contact", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1823 sizeof(desc) / sizeof(*desc), desc, &result);
1824 napi_set_named_property(env, exports, "Contact", result);
1825 return exports;
1826 }
1827
DeclareEmailConst(napi_env env,napi_value exports)1828 napi_value DeclareEmailConst(napi_env env, napi_value exports)
1829 {
1830 // Email
1831 napi_property_descriptor desc[] = {
1832 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1833 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::CUSTOM_LABEL))),
1834 DECLARE_NAPI_STATIC_PROPERTY("EMAIL_HOME",
1835 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_HOME))),
1836 DECLARE_NAPI_STATIC_PROPERTY("EMAIL_WORK",
1837 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_WORK))),
1838 DECLARE_NAPI_STATIC_PROPERTY("EMAIL_OTHER",
1839 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_OTHER))),
1840 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1841 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::INVALID_LABEL_ID))),
1842 };
1843 napi_value result = nullptr;
1844 napi_define_class(env, "Email", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1845 sizeof(desc) / sizeof(*desc), desc, &result);
1846 napi_set_named_property(env, exports, "Email", result);
1847 return exports;
1848 }
1849
DeclareEventConst(napi_env env,napi_value exports)1850 napi_value DeclareEventConst(napi_env env, napi_value exports)
1851 {
1852 // Event
1853 napi_property_descriptor desc[] = {
1854 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1855 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::CUSTOM_LABEL))),
1856 DECLARE_NAPI_STATIC_PROPERTY("EVENT_ANNIVERSARY",
1857 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_ANNIVERSARY))),
1858 DECLARE_NAPI_STATIC_PROPERTY("EVENT_OTHER",
1859 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_OTHER))),
1860 DECLARE_NAPI_STATIC_PROPERTY("EVENT_BIRTHDAY",
1861 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_BIRTHDAY))),
1862 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1863 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::INVALID_LABEL_ID))),
1864 };
1865 napi_value result = nullptr;
1866 napi_define_class(env, "Event", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1867 sizeof(desc) / sizeof(*desc), desc, &result);
1868 napi_set_named_property(env, exports, "Event", result);
1869 return exports;
1870 }
1871
DeclareImAddressConst(napi_env env,napi_value exports)1872 napi_value DeclareImAddressConst(napi_env env, napi_value exports)
1873 {
1874 // ImAddress
1875 napi_property_descriptor desc[] = {
1876 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1877 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::CUSTOM_LABEL))),
1878 DECLARE_NAPI_STATIC_PROPERTY("IM_AIM",
1879 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_AIM))),
1880 DECLARE_NAPI_STATIC_PROPERTY("IM_MSN",
1881 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_MSN))),
1882 DECLARE_NAPI_STATIC_PROPERTY("IM_YAHOO",
1883 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_YAHOO))),
1884 DECLARE_NAPI_STATIC_PROPERTY("IM_SKYPE",
1885 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_SKYPE))),
1886 DECLARE_NAPI_STATIC_PROPERTY("IM_QQ",
1887 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_QQ))),
1888 DECLARE_NAPI_STATIC_PROPERTY("IM_ICQ",
1889 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_ICQ))),
1890 DECLARE_NAPI_STATIC_PROPERTY("IM_JABBER",
1891 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_JABBER))),
1892 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1893 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::INVALID_LABEL_ID))),
1894 };
1895 napi_value result = nullptr;
1896 napi_define_class(env, "ImAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1897 sizeof(desc) / sizeof(*desc), desc, &result);
1898 napi_set_named_property(env, exports, "ImAddress", result);
1899 return exports;
1900 }
1901
DeclarePhoneNumberConst(napi_env env,napi_value exports)1902 napi_value DeclarePhoneNumberConst(napi_env env, napi_value exports)
1903 {
1904 // PhoneNumber
1905 napi_property_descriptor desc[] = {
1906 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1907 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::CUSTOM_LABEL))),
1908 DECLARE_NAPI_STATIC_PROPERTY("NUM_HOME",
1909 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_HOME))),
1910 DECLARE_NAPI_STATIC_PROPERTY("NUM_MOBILE",
1911 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MOBILE))),
1912 DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK",
1913 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK))),
1914 DECLARE_NAPI_STATIC_PROPERTY("NUM_FAX_WORK",
1915 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_FAX_WORK))),
1916 DECLARE_NAPI_STATIC_PROPERTY("NUM_FAX_HOME",
1917 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_FAX_HOME))),
1918 DECLARE_NAPI_STATIC_PROPERTY("NUM_PAGER",
1919 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_PAGER))),
1920 DECLARE_NAPI_STATIC_PROPERTY("NUM_OTHER",
1921 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_OTHER))),
1922 DECLARE_NAPI_STATIC_PROPERTY("NUM_CALLBACK",
1923 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_CALLBACK))),
1924 DECLARE_NAPI_STATIC_PROPERTY("NUM_CAR",
1925 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_CAR))),
1926 DECLARE_NAPI_STATIC_PROPERTY("NUM_COMPANY_MAIN",
1927 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_COMPANY_MAIN))),
1928 DECLARE_NAPI_STATIC_PROPERTY("NUM_ISDN",
1929 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_ISDN))),
1930 DECLARE_NAPI_STATIC_PROPERTY("NUM_MAIN",
1931 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MAIN))),
1932 DECLARE_NAPI_STATIC_PROPERTY("NUM_OTHER_FAX",
1933 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_OTHER_FAX))),
1934 DECLARE_NAPI_STATIC_PROPERTY("NUM_RADIO",
1935 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_RADIO))),
1936 DECLARE_NAPI_STATIC_PROPERTY("NUM_TELEX",
1937 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_TELEX))),
1938 DECLARE_NAPI_STATIC_PROPERTY("NUM_TTY_TDD",
1939 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_TTY_TDD))),
1940 DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK_MOBILE",
1941 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK_MOBILE))),
1942 DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK_PAGER",
1943 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK_PAGER))),
1944 DECLARE_NAPI_STATIC_PROPERTY("NUM_ASSISTANT",
1945 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_ASSISTANT))),
1946 DECLARE_NAPI_STATIC_PROPERTY("NUM_MMS",
1947 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MMS))),
1948 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1949 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::INVALID_LABEL_ID))),
1950 };
1951 napi_value result = nullptr;
1952 napi_define_class(env, "PhoneNumber", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1953 sizeof(desc) / sizeof(*desc), desc, &result);
1954 napi_set_named_property(env, exports, "PhoneNumber", result);
1955 return exports;
1956 }
1957
DeclarePostalAddressConst(napi_env env,napi_value exports)1958 napi_value DeclarePostalAddressConst(napi_env env, napi_value exports)
1959 {
1960 // PostalAddress
1961 napi_property_descriptor desc[] = {
1962 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1963 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::CUSTOM_LABEL))),
1964 DECLARE_NAPI_STATIC_PROPERTY("ADDR_HOME",
1965 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_HOME))),
1966 DECLARE_NAPI_STATIC_PROPERTY("ADDR_WORK",
1967 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_WORK))),
1968 DECLARE_NAPI_STATIC_PROPERTY("ADDR_OTHER",
1969 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_OTHER))),
1970 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1971 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::INVALID_LABEL_ID))),
1972 };
1973 napi_value result = nullptr;
1974 napi_define_class(env, "PostalAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1975 sizeof(desc) / sizeof(*desc), desc, &result);
1976 napi_set_named_property(env, exports, "PostalAddress", result);
1977 return exports;
1978 }
1979
DeclareRelationConst(napi_env env,napi_value exports)1980 napi_value DeclareRelationConst(napi_env env, napi_value exports)
1981 {
1982 // Relation
1983 napi_property_descriptor desc[] = {
1984 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1985 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::CUSTOM_LABEL))),
1986 DECLARE_NAPI_STATIC_PROPERTY("RELATION_ASSISTANT",
1987 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_ASSISTANT))),
1988 DECLARE_NAPI_STATIC_PROPERTY("RELATION_BROTHER",
1989 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_BROTHER))),
1990 DECLARE_NAPI_STATIC_PROPERTY("RELATION_CHILD",
1991 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_CHILD))),
1992 DECLARE_NAPI_STATIC_PROPERTY("RELATION_DOMESTIC_PARTNER",
1993 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_DOMESTIC_PARTNER))),
1994 DECLARE_NAPI_STATIC_PROPERTY("RELATION_FATHER",
1995 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_FATHER))),
1996 DECLARE_NAPI_STATIC_PROPERTY("RELATION_FRIEND",
1997 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_FRIEND))),
1998 DECLARE_NAPI_STATIC_PROPERTY("RELATION_MANAGER",
1999 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_MANAGER))),
2000 DECLARE_NAPI_STATIC_PROPERTY("RELATION_MOTHER",
2001 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_MOTHER))),
2002 DECLARE_NAPI_STATIC_PROPERTY("RELATION_PARENT",
2003 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_PARENT))),
2004 DECLARE_NAPI_STATIC_PROPERTY("RELATION_PARTNER",
2005 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_PARTNER))),
2006 DECLARE_NAPI_STATIC_PROPERTY("RELATION_REFERRED_BY",
2007 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_REFERRED_BY))),
2008 DECLARE_NAPI_STATIC_PROPERTY("RELATION_RELATIVE",
2009 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_RELATIVE))),
2010 DECLARE_NAPI_STATIC_PROPERTY("RELATION_SISTER",
2011 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_SISTER))),
2012 DECLARE_NAPI_STATIC_PROPERTY("RELATION_SPOUSE",
2013 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_SPOUSE))),
2014 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
2015 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::INVALID_LABEL_ID))),
2016 };
2017 napi_value result = nullptr;
2018 napi_define_class(env, "Relation", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
2019 sizeof(desc) / sizeof(*desc), desc, &result);
2020 napi_set_named_property(env, exports, "Relation", result);
2021 return exports;
2022 }
2023
DeclareSipAddressConst(napi_env env,napi_value exports)2024 napi_value DeclareSipAddressConst(napi_env env, napi_value exports)
2025 {
2026 // SipAddress
2027 napi_property_descriptor desc[] = {
2028 DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
2029 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::CUSTOM_LABEL))),
2030 DECLARE_NAPI_STATIC_PROPERTY("SIP_HOME",
2031 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_HOME))),
2032 DECLARE_NAPI_STATIC_PROPERTY("SIP_WORK",
2033 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_WORK))),
2034 DECLARE_NAPI_STATIC_PROPERTY("SIP_OTHER",
2035 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_OTHER))),
2036 DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
2037 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::INVALID_LABEL_ID))),
2038 };
2039 napi_value result = nullptr;
2040 napi_define_class(env, "SipAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
2041 sizeof(desc) / sizeof(*desc), desc, &result);
2042 napi_set_named_property(env, exports, "SipAddress", result);
2043 return exports;
2044 }
2045
DeclareAttributeConst(napi_env env,napi_value exports)2046 napi_value DeclareAttributeConst(napi_env env, napi_value exports)
2047 {
2048 // Attribute
2049 napi_property_descriptor desc[] = {
2050 DECLARE_NAPI_STATIC_PROPERTY("ATTR_CONTACT_EVENT",
2051 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_CONTACT_EVENT))),
2052 DECLARE_NAPI_STATIC_PROPERTY("ATTR_EMAIL",
2053 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_EMAIL))),
2054 DECLARE_NAPI_STATIC_PROPERTY("ATTR_GROUP_MEMBERSHIP",
2055 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_GROUP_MEMBERSHIP))),
2056 DECLARE_NAPI_STATIC_PROPERTY("ATTR_IM",
2057 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_IM))),
2058 DECLARE_NAPI_STATIC_PROPERTY("ATTR_NAME",
2059 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NAME))),
2060 DECLARE_NAPI_STATIC_PROPERTY("ATTR_NICKNAME",
2061 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NICKNAME))),
2062 DECLARE_NAPI_STATIC_PROPERTY("ATTR_NOTE",
2063 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NOTE))),
2064 DECLARE_NAPI_STATIC_PROPERTY("ATTR_ORGANIZATION",
2065 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_ORGANIZATION))),
2066 DECLARE_NAPI_STATIC_PROPERTY("ATTR_PHONE",
2067 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_PHONE))),
2068 DECLARE_NAPI_STATIC_PROPERTY("ATTR_PORTRAIT",
2069 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_PORTRAIT))),
2070 DECLARE_NAPI_STATIC_PROPERTY("ATTR_POSTAL_ADDRESS",
2071 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_POSTAL_ADDRESS))),
2072 DECLARE_NAPI_STATIC_PROPERTY("ATTR_RELATION",
2073 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_RELATION))),
2074 DECLARE_NAPI_STATIC_PROPERTY("ATTR_SIP_ADDRESS",
2075 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_SIP_ADDRESS))),
2076 DECLARE_NAPI_STATIC_PROPERTY("ATTR_WEBSITE",
2077 ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_WEBSITE))),
2078 };
2079 napi_value result = nullptr;
2080 napi_define_class(env, "Attribute", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
2081 sizeof(desc) / sizeof(*desc), desc, &result);
2082 napi_set_named_property(env, exports, "Attribute", result);
2083 return exports;
2084 }
2085
Init(napi_env env,napi_value exports)2086 void Init(napi_env env, napi_value exports)
2087 {
2088 napi_property_descriptor exportFuncs[] = {
2089 DECLARE_NAPI_FUNCTION("addContact", OHOS::ContactsApi::AddContact),
2090 DECLARE_NAPI_FUNCTION("deleteContact", OHOS::ContactsApi::DeleteContact),
2091 DECLARE_NAPI_FUNCTION("updateContact", OHOS::ContactsApi::UpdateContact),
2092 DECLARE_NAPI_FUNCTION("queryContact", OHOS::ContactsApi::QueryContact),
2093 DECLARE_NAPI_FUNCTION("queryContacts", OHOS::ContactsApi::QueryContacts),
2094 DECLARE_NAPI_FUNCTION("queryContactsByEmail", OHOS::ContactsApi::QueryContactsByEmail),
2095 DECLARE_NAPI_FUNCTION("queryContactsByPhoneNumber", OHOS::ContactsApi::QueryContactsByPhoneNumber),
2096 DECLARE_NAPI_FUNCTION("queryGroups", OHOS::ContactsApi::QueryGroups),
2097 DECLARE_NAPI_FUNCTION("queryHolders", OHOS::ContactsApi::QueryHolders),
2098 DECLARE_NAPI_FUNCTION("queryKey", OHOS::ContactsApi::QueryKey),
2099 DECLARE_NAPI_FUNCTION("queryMyCard", OHOS::ContactsApi::QueryMyCard),
2100 DECLARE_NAPI_FUNCTION("isMyCard", OHOS::ContactsApi::IsMyCard),
2101 DECLARE_NAPI_FUNCTION("isLocalContact", OHOS::ContactsApi::IsLocalContact),
2102 };
2103 napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs);
2104 // Declare class const initialization
2105 DeclareContactConst(env, exports);
2106 DeclareEmailConst(env, exports);
2107 DeclareEventConst(env, exports);
2108 DeclareImAddressConst(env, exports);
2109 DeclarePhoneNumberConst(env, exports);
2110 DeclarePostalAddressConst(env, exports);
2111 DeclareRelationConst(env, exports);
2112 DeclareSipAddressConst(env, exports);
2113 DeclareAttributeConst(env, exports);
2114 }
2115 } // namespace ContactsApi
2116 } // namespace OHOS
2117