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