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