1 /*
2  * Copyright (C) 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 #include "vcard_contact.h"
16 
17 #include <numeric>
18 
19 #include "telephony_errors.h"
20 #include "telephony_log_wrapper.h"
21 #include "vcard_configuration.h"
22 #include "vcard_utils.h"
23 
24 namespace OHOS {
25 namespace Telephony {
26 std::mutex mutex_;
Init()27 void VCardContact::Init() {}
28 
AddRawData(std::shared_ptr<VCardRawData> rawData, int32_t &errorCode)29 void VCardContact::AddRawData(std::shared_ptr<VCardRawData> rawData, int32_t &errorCode)
30 {
31     if (rawData == nullptr) {
32         return;
33     }
34     std::string name;
35     std::string rawValue;
36     std::string byte;
37     std::vector<std::string> values;
38     std::vector<std::string> groups;
39     std::map<std::string, std::vector<std::string>> parasMap;
40     name = rawData->GetName();
41     rawValue = rawData->GetRawValue();
42     byte = rawData->GetByte();
43     values = rawData->GetValue();
44     groups = rawData->GetGroup();
45     parasMap = rawData->GetParasMap();
46     if (values.size() == 0 && byte.empty()) {
47         return;
48     }
49     std::string propValue = (values.size() != 0) ? VCardUtils::TrimListToString(values) : "";
50     AddDatas(name, rawValue, byte, values, propValue, groups, parasMap);
51 }
52 
AddDatas(std::string name, std::string rawValue, std::string byte, std::vector<std::string> values, std::string propValue, std::vector<std::string> groups, std::map<std::string, std::vector<std::string>> parasMap)53 void VCardContact::AddDatas(std::string name, std::string rawValue, std::string byte, std::vector<std::string> values,
54     std::string propValue, std::vector<std::string> groups, std::map<std::string, std::vector<std::string>> parasMap)
55 {
56     std::lock_guard<std::mutex> lock(mutex_);
57     if (name == VCARD_TYPE_VERSION) {
58         vCardType_ = rawValue;
59     } else if (name == VCARD_TYPE_FN || name == VCARD_TYPE_NAME || name == VCARD_TYPE_N ||
60                name == VCARD_TYPE_SORT_STRING || name == VCARD_TYPE_X_PHONETIC_FIRST_NAME ||
61                name == VCARD_TYPE_X_PHONETIC_LAST_NAME || name == VCARD_TYPE_X_PHONETIC_MIDDLE_NAME) {
62         AddNameData(name, rawValue, values, parasMap, propValue);
63     } else if (name == VCARD_TYPE_NICKNAME) {
64         HandleNickName(propValue);
65     } else if (name == VCARD_TYPE_SOUND) {
66         AddSoundDatas(rawValue, propValue, values, parasMap);
67     } else if (name == VCARD_TYPE_ADR) {
68         AddPostalDatas(rawValue, propValue, values, parasMap);
69     } else if (name == VCARD_TYPE_EMAIL) {
70         AddEmailsData(rawValue, propValue, values, parasMap);
71     } else if (name == VCARD_TYPE_ORG) {
72         AddOrganizationsData(rawValue, propValue, values, parasMap);
73     } else if (name == VCARD_TYPE_TITLE) {
74         HandleTitleValue((parasMap.size() != 0) ? propValue : rawValue);
75     } else if (name == VCARD_TYPE_PHOTO || name == VCARD_TYPE_LOGO) {
76         AddPhotoDatas(byte, rawValue, propValue, values, parasMap);
77     } else if (name == VCARD_TYPE_TEL) {
78         AddPhonesData(rawValue, propValue, values, parasMap);
79     }
80     AddOtherDatas(name, rawValue, byte, values, propValue, groups, parasMap);
81 }
82 
AddOtherDatas(std::string name, std::string rawValue, std::string byte, std::vector<std::string> values, std::string propValue, std::vector<std::string> groups, std::map<std::string, std::vector<std::string>> parasMap)83 void VCardContact::AddOtherDatas(std::string name, std::string rawValue, std::string byte,
84     std::vector<std::string> values, std::string propValue, std::vector<std::string> groups,
85     std::map<std::string, std::vector<std::string>> parasMap)
86 {
87     if (name == VCARD_TYPE_X_SKYPE_PSTNNUMBER) {
88         AddSkypePstnNumDatas(propValue, parasMap);
89     } else if (name == VCARD_TYPE_NOTE) {
90         AddNote((parasMap.size() != 0) ? propValue : rawValue);
91     } else if (name == VCARD_TYPE_URL) {
92         AddWebSiteDatas(rawValue, propValue, values, parasMap);
93     } else if (name == VCARD_TYPE_BDAY) {
94         AddBirthdayDatas(rawValue);
95     } else if (name == VCARD_TYPE_ANNIVERSARY) {
96         AddAnniversaryDatas(propValue);
97     } else if (name == VCARD_TYPE_IMPP) {
98         AddImppDatas(propValue, parasMap);
99     } else if (name == VCARD_TYPE_X_SIP) {
100         AddSipData(rawValue, parasMap, propValue);
101     } else if (name == VCARD_TYPE_X_OHOS_CUSTOM || name == VCARD_TYPE_X_MOBILE_CUSTOM) {
102         AddCustom(rawValue, parasMap, propValue);
103     }
104     AddRemainDatas(name, rawValue, values, propValue, parasMap);
105 }
106 
AddRemainDatas(std::string name, std::string rawValue, std::vector<std::string> values, std::string propValue, std::map<std::string, std::vector<std::string>> parasMap)107 void VCardContact::AddRemainDatas(std::string name, std::string rawValue, std::vector<std::string> values,
108     std::string propValue, std::map<std::string, std::vector<std::string>> parasMap)
109 {
110     if (name == VCARD_TYPE_X_AIM || name == VCARD_TYPE_X_MSN || name == VCARD_TYPE_X_YAHOO ||
111         name == VCARD_TYPE_X_ICQ || name == VCARD_TYPE_X_JABBER || name == VCARD_TYPE_X_QQ ||
112         name == VCARD_TYPE_X_SKYPE_USERNAME || name == VCARD_TYPE_X_HUANLIAO) {
113         AddIms(name, rawValue, propValue, values, parasMap);
114     } else if (name == VCARD_TYPE_X_GROUP) {
115         AddGroups(rawValue);
116     } else {
117         TELEPHONY_LOGI("No need to do anything");
118     }
119 }
120 
CheckNameExist()121 void VCardContact::CheckNameExist()
122 {
123     if (nameData_ == nullptr) {
124         return;
125     }
126     if (!nameData_->GetPrefix().empty() || !nameData_->GetFamily().empty() || !nameData_->GetMiddle().empty() ||
127         !nameData_->GetSuffix().empty() || !nameData_->GetFormatted().empty() || !nameData_->GetSort().empty() ||
128         !nameData_->GetFormatted().empty() || !nameData_->GetPhoneticFamily().empty() ||
129         !nameData_->GetPhoneticGiven().empty() || !nameData_->GetPhoneticMiddle().empty() ||
130         !nameData_->GetDisplayName().empty()) {
131         return;
132     }
133     for (auto data : phones_) {
134         if (data != nullptr && !data->GetNumber().empty()) {
135             TELEPHONY_LOGI("replace phone as name: %{public}s", data->GetNumber().c_str());
136             nameData_->setDispalyName(data->GetNumber());
137             return;
138         }
139     }
140     for (auto data : emails_) {
141         if (data != nullptr && !data->GetAddress().empty()) {
142             TELEPHONY_LOGI("replace email as name: %{public}s", data->GetAddress().c_str());
143             nameData_->setDispalyName(data->GetAddress());
144             return;
145         }
146     }
147 }
148 
BuildContactData(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues)149 int32_t VCardContact::BuildContactData(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues)
150 {
151     CheckNameExist();
152     BuildValuesBucket(rawId, contactDataValues, nameData_);
153     if (!birthday_->GetBirthday().empty()) {
154         BuildValuesBucket(rawId, contactDataValues, birthday_);
155     }
156     if (!anniversary_->GetAnniversary().empty()) {
157         BuildValuesBucket(rawId, contactDataValues, anniversary_);
158     }
159     BuildValuesBuckets(rawId, contactDataValues, phones_);
160     BuildValuesBuckets(rawId, contactDataValues, emails_);
161     BuildValuesBuckets(rawId, contactDataValues, postals_);
162     BuildValuesBuckets(rawId, contactDataValues, organizations_);
163     BuildValuesBuckets(rawId, contactDataValues, ims_);
164     BuildValuesBuckets(rawId, contactDataValues, photos_);
165     BuildValuesBuckets(rawId, contactDataValues, websites_);
166     BuildValuesBuckets(rawId, contactDataValues, sips_);
167     BuildValuesBuckets(rawId, contactDataValues, nicknames_);
168     BuildValuesBuckets(rawId, contactDataValues, notes_);
169     BuildValuesBuckets(rawId, contactDataValues, relations_);
170     BuildValuesBuckets(rawId, contactDataValues, events_);
171     BuildValuesBuckets(rawId, contactDataValues, groups_);
172     return TELEPHONY_SUCCESS;
173 }
174 
BuildValuesBucket(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues, std::shared_ptr<VCardContactData> contactData)175 void VCardContact::BuildValuesBucket(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues,
176     std::shared_ptr<VCardContactData> contactData)
177 {
178     if (contactData == nullptr) {
179         return;
180     }
181     OHOS::DataShare::DataShareValuesBucket valuesBucket;
182     valuesBucket.Put(ContactData::RAW_CONTACT_ID, std::to_string(rawId));
183     contactData->BuildValuesBucket(valuesBucket);
184     contactDataValues.push_back(valuesBucket);
185 }
186 
187 template<typename T>
BuildValuesBuckets(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues, std::vector<std::shared_ptr<T>> &contactDatas)188 void VCardContact::BuildValuesBuckets(int32_t rawId, std::vector<DataShare::DataShareValuesBucket> &contactDataValues,
189     std::vector<std::shared_ptr<T>> &contactDatas)
190 {
191     for (auto data : contactDatas) {
192         BuildValuesBucket(rawId, contactDataValues, data);
193     }
194 }
195 
BuildContact(std::shared_ptr<DataShare::DataShareResultSet> resultSet)196 int32_t VCardContact::BuildContact(std::shared_ptr<DataShare::DataShareResultSet> resultSet)
197 {
198     std::lock_guard<std::mutex> lock(mutex_);
199     if (resultSet == nullptr) {
200         return TELEPHONY_ERROR;
201     }
202     int32_t resultSetNum = resultSet->GoToFirstRow();
203     while (resultSetNum == 0) {
204         BuildOneData(resultSet);
205         resultSetNum = resultSet->GoToNextRow();
206     }
207     return TELEPHONY_SUCCESS;
208 }
209 
BuildOneData(std::shared_ptr<DataShare::DataShareResultSet> resultSet)210 int32_t VCardContact::BuildOneData(std::shared_ptr<DataShare::DataShareResultSet> resultSet)
211 {
212     if (resultSet == nullptr) {
213         return TELEPHONY_ERROR;
214     }
215     int typeId = 0;
216     int columnIndexType = 0;
217     resultSet->GetColumnIndex(ContactData::TYPE_ID, columnIndexType);
218     resultSet->GetInt(columnIndexType, typeId);
219     switch (typeId) {
220         case TypeId::NAME: {
221             BuildData(resultSet, names_);
222             return TELEPHONY_SUCCESS;
223         }
224         case TypeId::PHONE: {
225             BuildData(resultSet, phones_);
226             return TELEPHONY_SUCCESS;
227         }
228         case TypeId::RELATION: {
229             BuildData(resultSet, relations_);
230             return TELEPHONY_SUCCESS;
231         }
232         case TypeId::IM: {
233             BuildData(resultSet, ims_);
234             return TELEPHONY_SUCCESS;
235         }
236         case TypeId::SIP_ADDRESS: {
237             BuildData(resultSet, sips_);
238             return TELEPHONY_SUCCESS;
239         }
240         default:
241             break;
242     }
243     return BuildOtherData(typeId, resultSet);
244 }
245 
BuildOtherData(int32_t typeId, std::shared_ptr<DataShare::DataShareResultSet> resultSet)246 int32_t VCardContact::BuildOtherData(int32_t typeId, std::shared_ptr<DataShare::DataShareResultSet> resultSet)
247 {
248     switch (typeId) {
249         case TypeId::NICKNAME: {
250             BuildData(resultSet, nicknames_);
251             return TELEPHONY_SUCCESS;
252         }
253         case TypeId::EMAIL: {
254             BuildData(resultSet, emails_);
255             return TELEPHONY_SUCCESS;
256         }
257         case TypeId::POSTAL_ADDRESS: {
258             BuildData(resultSet, postals_);
259             return TELEPHONY_SUCCESS;
260         }
261         case TypeId::ORGANIZATION: {
262             BuildData(resultSet, organizations_);
263             return TELEPHONY_SUCCESS;
264         }
265         case TypeId::WEBSITE: {
266             BuildData(resultSet, websites_);
267             return TELEPHONY_SUCCESS;
268         }
269         case TypeId::PHOTO: {
270             BuildData(resultSet, photos_);
271             return TELEPHONY_SUCCESS;
272         }
273         case TypeId::NOTE: {
274             BuildData(resultSet, notes_);
275             return TELEPHONY_SUCCESS;
276         }
277         case TypeId::CONTACT_EVENT: {
278             BuildData(resultSet, events_);
279             return TELEPHONY_SUCCESS;
280         }
281         case TypeId::GROUP: {
282             BuildData(resultSet, groups_);
283             return TELEPHONY_SUCCESS;
284         }
285         default:
286             break;
287     }
288     return TELEPHONY_SUCCESS;
289 }
290 
291 template<typename T>
BuildData( std::shared_ptr<DataShare::DataShareResultSet> resultSet, std::vector<std::shared_ptr<T>> &contactDatas)292 void VCardContact::BuildData(
293     std::shared_ptr<DataShare::DataShareResultSet> resultSet, std::vector<std::shared_ptr<T>> &contactDatas)
294 {
295     auto data = std::make_shared<T>();
296     data->BuildData(resultSet);
297     contactDatas.push_back(data);
298 }
299 
GetNameData()300 std::shared_ptr<VCardNameData> VCardContact::GetNameData()
301 {
302     return nameData_;
303 }
304 
GetNames()305 std::vector<std::shared_ptr<VCardNameData>> VCardContact::GetNames()
306 {
307     return names_;
308 }
309 
GetRelations()310 std::vector<std::shared_ptr<VCardRelationData>> VCardContact::GetRelations()
311 {
312     return relations_;
313 }
314 
GetIms()315 std::vector<std::shared_ptr<VCardImData>> VCardContact::GetIms()
316 {
317     return ims_;
318 }
319 
GetSips()320 std::vector<std::shared_ptr<VCardSipData>> VCardContact::GetSips()
321 {
322     return sips_;
323 }
324 
GetPhones()325 std::vector<std::shared_ptr<VCardPhoneData>> VCardContact::GetPhones()
326 {
327     return phones_;
328 }
329 
GetOrganizations()330 std::vector<std::shared_ptr<VCardOrganizationData>> VCardContact::GetOrganizations()
331 {
332     return organizations_;
333 }
334 
GetWebsites()335 std::vector<std::shared_ptr<VCardWebsiteData>> VCardContact::GetWebsites()
336 {
337     return websites_;
338 }
339 
GetPhotos()340 std::vector<std::shared_ptr<VCardPhotoData>> VCardContact::GetPhotos()
341 {
342     return photos_;
343 }
344 
GetEmails()345 std::vector<std::shared_ptr<VCardEmailData>> VCardContact::GetEmails()
346 {
347     return emails_;
348 }
349 
GetNicknames()350 std::vector<std::shared_ptr<VCardNicknameData>> VCardContact::GetNicknames()
351 {
352     return nicknames_;
353 }
354 
GetPostalDatas()355 std::vector<std::shared_ptr<VCardPostalData>> VCardContact::GetPostalDatas()
356 {
357     return postals_;
358 }
359 
GetEventDatas()360 std::vector<std::shared_ptr<VCardEventData>> VCardContact::GetEventDatas()
361 {
362     return events_;
363 }
364 
GetNotes()365 std::vector<std::shared_ptr<VCardNoteData>> VCardContact::GetNotes()
366 {
367     return notes_;
368 }
369 
GetBirthdays()370 std::shared_ptr<VCardBirthdayData> VCardContact::GetBirthdays()
371 {
372     return birthday_;
373 }
374 
GetGroups()375 std::vector<std::shared_ptr<VCardGroupData>> VCardContact::GetGroups()
376 {
377     return groups_;
378 }
379 
HandleName(std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)380 void VCardContact::HandleName(std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)
381 {
382     if (nameData_ == nullptr) {
383         return;
384     }
385     int32_t size = static_cast<int32_t>(values.size());
386     if (values.empty() || size == 0) {
387         return;
388     }
389     if (size > N_MAX_VALUE_SIZE) {
390         size = N_MAX_VALUE_SIZE;
391     }
392     switch (size) {
393         case SIZE_FIVE:
394             nameData_->SetSuffix(values[N_SUFFIX_VALUE_INDEX]);
395             [[fallthrough]]; // fall_through
396         case SIZE_FOUR:
397             nameData_->SetPrefix(values[N_PREFIX_VALUE_INDEX]);
398             [[fallthrough]]; // fall_through
399         case SIZE_THREE:
400             nameData_->SetMiddle(values[N_MIDDLE_VALUE_INDEX]);
401             [[fallthrough]]; // fall_through
402         case SIZE_TWO:
403             nameData_->SetGiven(values[N_GIVEN_VALUE_INDEX]);
404             [[fallthrough]]; // fall_through
405         default:
406             nameData_->SetFamily(values[N_FAMILY_VALUE_INDEX]);
407             break;
408     }
409 }
410 
HandleSortAsName(std::map<std::string, std::vector<std::string>> parasMap)411 void VCardContact::HandleSortAsName(std::map<std::string, std::vector<std::string>> parasMap)
412 {
413     if (nameData_ == nullptr) {
414         return;
415     }
416     if (vCardType_ == VERSION_30 &&
417         !(nameData_->GetPhoneticFamily().empty() && nameData_->GetPhoneticMiddle().empty() &&
418             nameData_->GetPhoneticGiven().empty())) {
419         return;
420     }
421     std::vector<std::string> sortAsList;
422     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_SORT_AS);
423     if (it == parasMap.end()) {
424         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_SORT_AS);
425         return;
426     } else {
427         sortAsList = it->second;
428     }
429 
430     if (sortAsList.size() > 0) {
431         std::vector<std::string> sortNames = VCardUtils::ConstructListFromValue(sortAsList[0], vCardType_);
432         int32_t size = static_cast<int32_t>(sortNames.size());
433         if (size > SORT_NAME_MAX_VALUE_SIZE) {
434             size = SORT_NAME_MAX_VALUE_SIZE;
435         }
436         switch (size) {
437             case SIZE_THREE:
438                 nameData_->SetPhoneticMiddle(sortNames[PHONETIC_MIDDLE_VALUE_INDEX]);
439                 [[fallthrough]]; // fall_through
440             case SIZE_TWO:
441                 nameData_->SetPhoneticGiven(sortNames[PHONETIC_GIVEN_VALUE_INDEX]);
442                 [[fallthrough]]; // fall_through
443             default:
444                 nameData_->SetPhoneticFamily(sortNames[PHONETIC_FAMILY_VALUE_INDEX]);
445                 break;
446         }
447     }
448 }
449 
HandleNickName(std::string nickName)450 void VCardContact::HandleNickName(std::string nickName)
451 {
452     std::shared_ptr<VCardNicknameData> nn = std::make_shared<VCardNicknameData>();
453     nn->SetNickName(nickName);
454     nicknames_.push_back(nn);
455 }
456 
HandlePhoneticNameFromSound(std::vector<std::string> elems)457 void VCardContact::HandlePhoneticNameFromSound(std::vector<std::string> elems)
458 {
459     if (nameData_ == nullptr) {
460         return;
461     }
462     if (nameData_->GetPhoneticFamily().empty() && nameData_->GetPhoneticMiddle().empty() &&
463         nameData_->GetPhoneticGiven().empty()) {
464         return;
465     }
466     int32_t size = static_cast<int32_t>(elems.size());
467     if (elems.empty() || size == 0) {
468         return;
469     }
470     size = (size > PHONE_NAME_SOUND_MAX_VALUE_SIZE) ? PHONE_NAME_SOUND_MAX_VALUE_SIZE : size;
471     if (elems[0].length() > 0) {
472         bool onlyFirstElemIsNonEmpty = true;
473         for (int32_t i = 1; i < size; i++) {
474             if (elems[i].length() > 0) {
475                 onlyFirstElemIsNonEmpty = false;
476                 break;
477             }
478         }
479         if (onlyFirstElemIsNonEmpty) {
480             std::vector<std::string> namesArray = VCardUtils::Split(elems[VALUE_INDEX_ZERO], " ");
481             int32_t nameArrayLength = static_cast<int32_t>(namesArray.size());
482             if (nameArrayLength == VALUE_LEN_THREE) {
483                 nameData_->SetPhoneticFamily(namesArray[VALUE_INDEX_ZERO]);
484                 nameData_->SetPhoneticMiddle(namesArray[VALUE_INDEX_ONE]);
485                 nameData_->SetPhoneticGiven(namesArray[VALUE_INDEX_TWO]);
486             } else if (nameArrayLength == VALUE_LEN_TWO) {
487                 nameData_->SetPhoneticFamily(namesArray[VALUE_INDEX_ZERO]);
488                 nameData_->SetPhoneticGiven(namesArray[VALUE_INDEX_ONE]);
489             } else {
490                 nameData_->SetPhoneticGiven(elems[VALUE_INDEX_ZERO]);
491             }
492             return;
493         }
494     }
495     switch (size) {
496         case SIZE_THREE:
497             nameData_->SetPhoneticMiddle(elems[VALUE_INDEX_TWO]);
498             break;
499         case SIZE_TWO:
500             nameData_->SetPhoneticGiven(elems[VALUE_INDEX_ONE]);
501             break;
502         default:
503             nameData_->SetPhoneticFamily(elems[VALUE_INDEX_ZERO]);
504             break;
505     }
506 }
507 
AddPostal(int32_t type, std::vector<std::string> propValueList, std::string label, bool isPrimary)508 void VCardContact::AddPostal(int32_t type, std::vector<std::string> propValueList, std::string label, bool isPrimary)
509 {
510     std::shared_ptr<VCardPostalData> pd = std::make_shared<VCardPostalData>();
511     pd->InitPostalData(propValueList, type, label);
512     postals_.push_back(pd);
513 }
514 
AddEmail(int32_t type, std::string data, std::string label, std::string displayname, bool isPrimary)515 void VCardContact::AddEmail(int32_t type, std::string data, std::string label, std::string displayname, bool isPrimary)
516 {
517     std::shared_ptr<VCardEmailData> ed = std::make_shared<VCardEmailData>();
518     ed->InitEmailData(data, std::to_string(type), label, displayname);
519     emails_.push_back(ed);
520 }
521 
HandleOrgValue(int32_t type, std::vector<std::string> orgList, std::map<std::string, std::vector<std::string>> paramMap, bool isPrimary)522 void VCardContact::HandleOrgValue(int32_t type, std::vector<std::string> orgList,
523     std::map<std::string, std::vector<std::string>> paramMap, bool isPrimary)
524 {
525     std::string phoneticName = BuildSinglePhoneticNameFromSortAsParam(paramMap);
526 
527     std::string organizationName;
528     std::string departmentName;
529     int32_t size = static_cast<int32_t>(orgList.size());
530     switch (size) {
531         case SIZE_ZERO:
532             organizationName = "";
533             departmentName = "";
534             break;
535         case SIZE_ONE:
536             organizationName = orgList[0];
537             departmentName = "";
538             break;
539         default:
540             organizationName = orgList[0];
541             std::string builder;
542             for (int32_t i = 1; i < size; i++) {
543                 if (i > 1) {
544                     builder += " ";
545                 }
546                 builder += orgList[i];
547             }
548             departmentName = builder;
549             break;
550     }
551 
552     if (organizations_.empty()) {
553         AddNewOrganization(organizationName, departmentName, "", "", phoneticName, type, isPrimary);
554         return;
555     }
556 
557     for (std::shared_ptr<VCardOrganizationData> organizationData : organizations_) {
558         if (organizationData == nullptr) {
559             return;
560         }
561         if (organizationData->GetOrganization().empty() && organizationData->GetDepartmentName().empty()) {
562             organizationData->SetOrganization(organizationName);
563             organizationData->SetDepartmentName(departmentName);
564             return;
565         }
566     }
567 
568     AddNewOrganization(organizationName, departmentName, "", "", phoneticName, type, isPrimary);
569 }
570 
BuildSinglePhoneticNameFromSortAsParam( std::map<std::string, std::vector<std::string>> paramMap)571 std::string VCardContact::BuildSinglePhoneticNameFromSortAsParam(
572     std::map<std::string, std::vector<std::string>> paramMap)
573 {
574     std::vector<std::string> sortAsList;
575     std::map<std::string, std::vector<std::string>>::iterator it = paramMap.find(VCARD_PARAM_SORT_AS);
576     if (it == paramMap.end()) {
577         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_SORT_AS);
578         return "";
579     } else {
580         sortAsList = it->second;
581     }
582     if (!sortAsList.empty()) {
583         std::vector<std::string> sortNames = VCardUtils::ConstructListFromValue(sortAsList.at(0), vCardType_);
584         std::string init = "";
585         std::string builder = std::accumulate(sortNames.begin(), sortNames.end(), init);
586         return builder;
587     } else {
588         return "";
589     }
590 }
591 
AddNewOrganization(std::string organizationName, std::string departmentName, std::string company, std::string titleName, std::string phoneticName, int32_t type, bool isPrimary)592 void VCardContact::AddNewOrganization(std::string organizationName, std::string departmentName, std::string company,
593     std::string titleName, std::string phoneticName, int32_t type, bool isPrimary)
594 {
595     std::shared_ptr<VCardOrganizationData> od = std::make_shared<VCardOrganizationData>();
596     od->InitOrganizationData(organizationName, departmentName, company, titleName, phoneticName, type);
597     organizations_.push_back(od);
598 }
599 
HandleTitleValue(std::string title)600 void VCardContact::HandleTitleValue(std::string title)
601 {
602     if (organizations_.empty()) {
603         AddNewOrganization("", "", "", title, "", VALUE_INDEX_ONE, false);
604         return;
605     }
606     for (std::shared_ptr<VCardOrganizationData> organizationData : organizations_) {
607         if (organizationData == nullptr) {
608             return;
609         }
610         if (organizationData->GetTitle().empty()) {
611             organizationData->SetTitle(title);
612             return;
613         }
614     }
615     AddNewOrganization("", "", "", title, "", VALUE_INDEX_ONE, false);
616 }
617 
AddPhotoBytes(std::string formatName, std::string photoBytes, bool isPrimary)618 void VCardContact::AddPhotoBytes(std::string formatName, std::string photoBytes, bool isPrimary)
619 {
620     std::shared_ptr<VCardPhotoData> pd = std::make_shared<VCardPhotoData>();
621     pd->InitPhotoData(formatName, photoBytes);
622     photos_.push_back(pd);
623 }
624 
HandleSipCase(std::string propValue, std::vector<std::string> typeCollection)625 void VCardContact::HandleSipCase(std::string propValue, std::vector<std::string> typeCollection)
626 {
627     if (propValue.empty()) {
628         return;
629     }
630     if (VCardUtils::StartWith(propValue, "sip:")) {
631         propValue = propValue.substr(VALUE_INDEX_FOUR);
632         if (propValue.length() == 0) {
633             return;
634         }
635     }
636     int32_t type = -1;
637     std::string label;
638     bool isPrimary = false;
639     if (!typeCollection.empty()) {
640         for (std::string typeStringOrg : typeCollection) {
641             std::string typeStringUpperCase = VCardUtils::ToUpper(typeStringOrg);
642             if (typeStringUpperCase == VCARD_PARAM_TYPE_PREF) {
643                 isPrimary = true;
644             } else if (typeStringUpperCase == VCARD_PARAM_TYPE_HOME) {
645                 type = static_cast<int32_t>(SipType::SIP_HOME);
646             } else if (typeStringUpperCase == VCARD_PARAM_TYPE_WORK) {
647                 type = static_cast<int32_t>(SipType::SIP_WORK);
648             } else if (type < 0) {
649                 label = (VCardUtils::StartWith(typeStringUpperCase, "X-")) ? typeStringOrg.substr(VALUE_INDEX_TWO)
650                                                                            : typeStringOrg;
651                 type = static_cast<int32_t>(SipType::CUSTOM_LABEL);
652             } else {
653                 TELEPHONY_LOGI("No need to do anything");
654             }
655         }
656     }
657     if (type < 0) {
658         type = static_cast<int32_t>(SipType::SIP_OTHER);
659     }
660     AddSip(propValue, type, label, isPrimary);
661 }
662 
AddPhone(int32_t type, std::string data, std::string label, bool isPrimary)663 void VCardContact::AddPhone(int32_t type, std::string data, std::string label, bool isPrimary)
664 {
665     std::string builder;
666     std::string trimmed = data;
667     std::string formattedNumber;
668     if (type == static_cast<int32_t>(PhoneVcType::NUM_PAGER) ||
669         VCardConfiguration::RefrainPhoneNumberFormatting(VCardUtils::VcardtypeToInt(vCardType_))) {
670         formattedNumber = trimmed;
671     } else {
672         bool hasPauseOrWait = false;
673         std::size_t length = trimmed.length();
674         for (std::size_t i = 0; i < length; i++) {
675             char ch = trimmed[i];
676             if (ch == 'p' || ch == 'P') {
677                 builder += ',';
678                 hasPauseOrWait = true;
679             } else if (ch == 'w' || ch == 'W') {
680                 builder += ';';
681                 hasPauseOrWait = true;
682             } else if (((ch >= '0' && ch <= '9') || ch == '*' || ch == '#') || (i == 0 && ch == '+')) {
683                 builder += ch;
684             } else {
685                 TELEPHONY_LOGI("No need to do anything");
686             }
687         }
688         if (!hasPauseOrWait) {
689             formattedNumber = VCardUtils::FormatNumber(builder);
690         } else {
691             formattedNumber = builder;
692         }
693     }
694     std::shared_ptr<VCardPhoneData> object = std::make_shared<VCardPhoneData>();
695     object->InitPhoneData(formattedNumber, type, label, isPrimary);
696     phones_.push_back(object);
697 }
698 
AddSip(std::string sipData, int32_t type, std::string label, bool isPrimary)699 void VCardContact::AddSip(std::string sipData, int32_t type, std::string label, bool isPrimary)
700 {
701     std::shared_ptr<VCardSipData> object = std::make_shared<VCardSipData>();
702     object->InitSipData(sipData, type, label);
703     sips_.push_back(object);
704 }
705 
AddNote(const std::string note)706 void VCardContact::AddNote(const std::string note)
707 {
708     std::shared_ptr<VCardNoteData> object = std::make_shared<VCardNoteData>();
709     object->InitNoteData(note);
710     notes_.push_back(object);
711 }
712 
AddIms(std::string name, std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)713 void VCardContact::AddIms(std::string name, std::string rawValue, std::string propValue,
714     std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)
715 {
716     int32_t labeId = VCardUtils::GetLabelIdFromImType(name);
717     std::shared_ptr<VCardImData> object = std::make_shared<VCardImData>();
718     std::vector<std::string> valueList = GetValueListFromParasMap(rawValue, propValue, parasMap);
719     for (std::string value : valueList) {
720         object->SetAddress(value);
721     }
722     object->SetLabelId(std::to_string(labeId));
723     ims_.push_back(object);
724 }
725 
AddNameData(std::string name, std::string rawValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)726 void VCardContact::AddNameData(std::string name, std::string rawValue, std::vector<std::string> values,
727     std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)
728 {
729     if (nameData_ == nullptr) {
730         return;
731     }
732     if (name == VCARD_TYPE_FN) {
733         nameData_->setDispalyName((values.size() != 0) ? values[0] : "");
734     } else if (name == VCARD_TYPE_N) {
735         HandleSortAsName(parasMap);
736         HandleName(values, parasMap);
737     } else if (name == VCARD_TYPE_NAME) {
738         if (nameData_->GetFormatted().empty()) {
739             nameData_->SetFormatted(propValue);
740         }
741     } else if (name == VCARD_TYPE_SORT_STRING) {
742         nameData_->setSort(propValue);
743     } else if (name == VCARD_TYPE_X_PHONETIC_FIRST_NAME) {
744         std::vector<std::string> valueList = GetValueListFromParasMap(rawValue, propValue, parasMap);
745         nameData_->SetPhoneticGiven((valueList.size() != 0) ? valueList[0] : "");
746     } else if (name == VCARD_TYPE_X_PHONETIC_MIDDLE_NAME) {
747         std::vector<std::string> valueList = GetValueListFromParasMap(rawValue, propValue, parasMap);
748         nameData_->SetPhoneticMiddle((valueList.size() != 0) ? valueList[0] : "");
749     } else if (name == VCARD_TYPE_X_PHONETIC_LAST_NAME) {
750         std::vector<std::string> valueList = GetValueListFromParasMap(rawValue, propValue, parasMap);
751         nameData_->SetPhoneticFamily((valueList.size() != 0) ? valueList[0] : "");
752     } else {
753         TELEPHONY_LOGI("No need to do anything");
754     }
755 }
756 
AddCustom( std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)757 void VCardContact::AddCustom(
758     std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)
759 {
760     std::vector<std::string> values = GetValueListFromParasMap(rawValue, propValue, parasMap);
761     std::string type = (values.size() != 0) ? values[0] : "";
762     if (type == TypeData::NICKNAME) {
763         std::shared_ptr<VCardNicknameData> object = std::make_shared<VCardNicknameData>();
764         int i = 0;
765         for (std::string value : values) {
766             if (i == SIZE_ONE) {
767                 object->SetNickName(value);
768                 break;
769             }
770             i++;
771         }
772         nicknames_.push_back(object);
773     } else if (type == TypeData::RELATION || type == VCARD_TYPE_X_MOBILE_RELATION) {
774         std::shared_ptr<VCardRelationData> object = std::make_shared<VCardRelationData>();
775         int i = 0;
776         for (std::string value : values) {
777             if (i == SIZE_ONE) {
778                 object->SetRelationName(value);
779             } else if (i == SIZE_TWO) {
780                 value = value == std::to_string(VALUE_INDEX_ZERO) ?
781                     std::to_string(static_cast<int32_t>(RelationType::CUSTOM_LABEL)) : value;
782                 object->SetLabelId(value);
783             } else if (i == SIZE_THREE) {
784                 object->SetLabelName(value);
785                 break;
786             }
787             i++;
788         }
789         relations_.push_back(object);
790     } else if (type == TypeData::CONTACT_EVENT || type == VCARD_TYPE_X_MOBILE_EVENTS) {
791         std::shared_ptr<VCardEventData> object = std::make_shared<VCardEventData>();
792         int i = 0;
793         for (std::string value : values) {
794             if (i == SIZE_ONE) {
795                 object->SetEventDate(value);
796             } else if (i == SIZE_TWO) {
797                 value = ConvertHarmonyEvents(type, value);
798                 object->SetLabelId(value);
799             } else if (i == SIZE_THREE) {
800                 object->SetLabelName(value);
801                 break;
802             }
803             i++;
804         }
805         events_.push_back(object);
806     }
807 }
808 
ConvertHarmonyEvents(std::string type, std::string value)809 std::string VCardContact::ConvertHarmonyEvents(std::string type, std::string value)
810 {
811     if (type != VCARD_TYPE_X_MOBILE_EVENTS) {
812         return value;
813     }
814     std::string convertedValue = value;
815     if (value == std::to_string(static_cast<int32_t>(EventHM4Type::EVENT_HM4_ANNIVERSARY))) {
816         convertedValue = std::to_string(static_cast<int32_t>(EventType::EVENT_ANNIVERSARY));
817     }
818     if (value == std::to_string(static_cast<int32_t>(EventHM4Type::EVENT_HM4_OTHER))) {
819         convertedValue = std::to_string(static_cast<int32_t>(EventType::EVENT_OTHER));
820     }
821     if (value == std::to_string(static_cast<int32_t>(EventHM4Type::EVENT_HM4_LUNAR_BIRTHDAY))) {
822         convertedValue = std::to_string(static_cast<int32_t>(EventType::EVENT_LUNAR_BIRTHDAY));
823     }
824     return convertedValue;
825 }
826 
SetSip( std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)827 void VCardContact::SetSip(
828     std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)
829 {
830     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
831     if (it == parasMap.end()) {
832         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
833         std::shared_ptr<VCardSipData> object = std::make_shared<VCardSipData>();
834         std::vector<std::string> values = VCardUtils::Split(propValue, ";");
835         for (size_t i = 0; i < values.size(); i++) {
836             if (i == SIZE_ZERO) {
837                 std::vector<std::string> address = VCardUtils::Split(values[i], ":");
838                 object->SetAddress((address.size() >= SIZE_TWO) ? address[1] : "");
839             } else if (i == SIZE_ONE) {
840                 object->SetLabelId(values[i]);
841             } else if (i == SIZE_TWO) {
842                 object->SetLabelName(values[i]);
843                 break;
844             }
845         }
846         sips_.push_back(object);
847     } else {
848         std::vector<std::string> typeCollection;
849         typeCollection = it->second;
850         HandleSipCase(propValue, typeCollection);
851     }
852 }
853 
AddSipData( std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)854 void VCardContact::AddSipData(
855     std::string rawValue, std::map<std::string, std::vector<std::string>> parasMap, std::string propValue)
856 {
857     if (parasMap.size() != 0 && !propValue.empty()) {
858         SetSip(rawValue, parasMap, propValue);
859         return;
860     }
861     std::shared_ptr<VCardSipData> object = std::make_shared<VCardSipData>();
862     std::vector<std::string> values = VCardUtils::Split(rawValue, ";");
863     for (size_t i = 0; i < values.size(); i++) {
864         if (i == SIZE_ZERO) {
865             std::vector<std::string> address = VCardUtils::Split(values[i], ":");
866             object->SetAddress((address.size() >= SIZE_TWO) ? address[1] : "");
867         }
868         if (i == SIZE_ONE) {
869             object->SetLabelId(values[i]);
870         }
871         if (i == SIZE_TWO) {
872             object->SetLabelName(values[i]);
873         }
874     }
875     sips_.push_back(object);
876 }
877 
AddPhonesData(std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)878 void VCardContact::AddPhonesData(std::string rawValue, std::string propValue, std::vector<std::string> values,
879     std::map<std::string, std::vector<std::string>> parasMap)
880 {
881     std::string phoneNumber;
882     bool isSip = false;
883     if (vCardType_ == VERSION_40) {
884         if (VCardUtils::StartWith(propValue, "sip:")) {
885             isSip = true;
886         } else if (VCardUtils::StartWith(propValue, "tel:")) {
887             phoneNumber = propValue.substr(VALUE_INDEX_FOUR);
888         } else {
889             phoneNumber = propValue;
890         }
891     } else {
892         phoneNumber = rawValue;
893     }
894     if (isSip) {
895         std::vector<std::string> typeCollection;
896         std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
897         if (it == parasMap.end()) {
898             TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
899             return;
900         } else {
901             typeCollection = it->second;
902         }
903         HandleSipCase(propValue, typeCollection);
904     } else {
905         HandlePhoneCase(phoneNumber, rawValue, propValue, values, parasMap);
906     }
907 }
908 
HandlePhoneCase(std::string phoneNumber, std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)909 void VCardContact::HandlePhoneCase(std::string phoneNumber, std::string rawValue, std::string propValue,
910     std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)
911 {
912     std::vector<std::string> typeCollection;
913     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
914     if (it == parasMap.end()) {
915         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
916         return;
917     } else {
918         typeCollection = it->second;
919     }
920     std::tuple<int32_t, std::string> result(NUM_MINUS_ONE, "-1");
921     VCardUtils::GetPhoneTypeFromStrings(typeCollection, phoneNumber, result);
922     int32_t type = NUM_MINUS_ONE;
923     std::string label;
924     if (std::get<0>(result) != NUM_MINUS_ONE && std::get<1>(result) == "-1") {
925         type = std::get<0>(result);
926         label = "";
927     } else if (std::get<0>(result) == NUM_MINUS_ONE && std::get<1>(result) != "-1") {
928         type = static_cast<int32_t>(PhoneVcType::CUSTOM_LABEL);
929         label = std::get<1>(result);
930     }
931     bool isPrimary = false;
932     bool contains = false;
933     if (std::find(typeCollection.begin(), typeCollection.end(), VCARD_PARAM_TYPE_PREF) != typeCollection.end()) {
934         contains = true;
935     }
936     if (!typeCollection.empty() && contains) {
937         isPrimary = true;
938     }
939     AddPhone(type, phoneNumber, label, isPrimary);
940 }
941 
AddOrganizationsData(std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)942 void VCardContact::AddOrganizationsData(std::string rawValue, std::string propValue, std::vector<std::string> values,
943     std::map<std::string, std::vector<std::string>> parasMap)
944 {
945     int32_t type = SIZE_ONE;
946     bool isPrimary = false;
947     if (parasMap.size() != 0) {
948         std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
949         if (it == parasMap.end()) {
950             TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
951             AddNewOrganization("", "", propValue, "", "", type, isPrimary);
952         } else {
953             HandleOrgValue(type, values, parasMap, isPrimary);
954         }
955     } else {
956         AddNewOrganization("", "", rawValue, "", "", type, isPrimary);
957     }
958 }
959 
AddEmailsData(std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)960 void VCardContact::AddEmailsData(std::string rawValue, std::string propValue, std::vector<std::string> values,
961     std::map<std::string, std::vector<std::string>> parasMap)
962 {
963     int32_t type = NUM_MINUS_ONE;
964     std::string label = "";
965     bool isPrimary = false;
966     std::vector<std::string> typeCollection;
967     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
968     if (it == parasMap.end()) {
969         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
970         return;
971     } else {
972         typeCollection = it->second;
973     }
974     if (!typeCollection.empty()) {
975         for (std::string typeStringOrg : typeCollection) {
976             std::string typeStringUpperCase = VCardUtils::ToUpper(typeStringOrg);
977             if (typeStringUpperCase == VCARD_PARAM_TYPE_PREF) {
978                 isPrimary = true;
979             } else if (typeStringUpperCase == VCARD_PARAM_TYPE_HOME) {
980                 type = static_cast<int32_t>(EmailType::EMAIL_HOME);
981             } else if (typeStringUpperCase == VCARD_PARAM_TYPE_WORK) {
982                 type = static_cast<int32_t>(EmailType::EMAIL_WORK);
983             } else if (typeStringUpperCase == VCARD_PARAM_TYPE_CELL) {
984                 type = VALUE_INDEX_FOUR;
985             } else if (type < 0) {
986                 label = (VCardUtils::StartWith(typeStringUpperCase, "X-")) ? typeStringOrg.substr(VALUE_INDEX_TWO)
987                                                                            : typeStringOrg;
988                 type = static_cast<int32_t>(EmailType::CUSTOM_LABEL);
989             } else {
990                 TELEPHONY_LOGI("No need to do anything");
991             }
992         }
993     }
994     if (type < 0) {
995         type = static_cast<int32_t>(EmailType::EMAIL_OTHER);
996     }
997     std::map<std::string, std::vector<std::string>>::iterator itCharset = parasMap.find(VCARD_PARAM_CHARSET);
998     std::map<std::string, std::vector<std::string>>::iterator itEncoding = parasMap.find(VCARD_PARAM_ENCODING);
999     std::vector<std::string> valueList =
1000         VCardUtils::Split(((itCharset != parasMap.end() && itEncoding != parasMap.end()) ? propValue : rawValue), ";");
1001     std::string address = (valueList.size() != 0) ? valueList[0] : "";
1002     std::string displayname = (valueList.size() >= SIZE_TWO) ? valueList[1] : "";
1003     AddEmail(type, address, label, displayname, isPrimary);
1004 }
1005 
AddPostalDatas(std::string rawValue, std::string propValue, std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)1006 void VCardContact::AddPostalDatas(std::string rawValue, std::string propValue, std::vector<std::string> values,
1007     std::map<std::string, std::vector<std::string>> parasMap)
1008 {
1009     bool valueIsAllEmpty = true;
1010     for (std::string value : values) {
1011         if (!value.empty()) {
1012             valueIsAllEmpty = false;
1013             break;
1014         }
1015     }
1016     if (valueIsAllEmpty) {
1017         return;
1018     }
1019     int32_t type = -1;
1020     std::string label = "";
1021     bool isPrimary = false;
1022     std::vector<std::string> typeCollection;
1023     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
1024     if (it == parasMap.end()) {
1025         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
1026         return;
1027     } else {
1028         typeCollection = it->second;
1029     }
1030     for (std::string typeStringOrg : typeCollection) {
1031         std::string typeStringUpperCase = VCardUtils::ToUpper(typeStringOrg);
1032         if (typeStringUpperCase == VCARD_PARAM_TYPE_PREF) {
1033             isPrimary = true;
1034         } else if (typeStringUpperCase == VCARD_PARAM_TYPE_HOME) {
1035             type = static_cast<int32_t>(PostalType::ADDR_HOME);
1036             label = "";
1037         } else if (typeStringUpperCase == VCARD_PARAM_TYPE_WORK ||
1038                    typeStringUpperCase == VCARD_PARAM_EXTRA_TYPE_COMPANY) {
1039             type = static_cast<int32_t>(PostalType::ADDR_WORK);
1040             label = "";
1041         } else if (typeStringUpperCase == VCARD_PARAM_ADR_TYPE_PARCEL ||
1042                    typeStringUpperCase == VCARD_PARAM_ADR_TYPE_DOM ||
1043                    typeStringUpperCase == VCARD_PARAM_ADR_TYPE_INTL) {
1044             // We do not have any appropriate way to store this information.
1045         } else if (type < 0) {
1046             type = static_cast<int32_t>(PostalType::CUSTOM_LABEL);
1047             label = (VCardUtils::StartWith(typeStringUpperCase, "X-")) ? typeStringOrg.substr(VALUE_INDEX_TWO)
1048                                                                        : typeStringOrg;
1049             if (VCardUtils::ToUpper(label) == VCARD_PARAM_ADR_EXTRA_TYPE_OTHER) {
1050                 type = static_cast<int32_t>(PostalType::ADDR_OTHER);
1051                 label = "";
1052             }
1053         } else {
1054             TELEPHONY_LOGI("No need to do anything");
1055         }
1056     }
1057     AddPostal(type < 0 ? static_cast<int32_t>(PostalType::ADDR_HOME) : type, values, label, isPrimary);
1058 }
1059 
1060 void VCardContact::AddSoundDatas(std::string rawValue, std::string propValue, std::vector<std::string> values,
1061     std::map<std::string, std::vector<std::string>> parasMap)
1062 {
1063     std::vector<std::string> typeList;
1064     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
1065     if (it == parasMap.end()) {
1066         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
1067         return;
1068     } else {
1069         typeList = it->second;
1070     }
1071     bool contains = false;
1072     if (std::find(typeList.begin(), typeList.end(), VCARD_PARAM_X_IRMC_N) != typeList.end()) {
1073         contains = true;
1074     }
1075     if (typeList.size() > 0 && contains) {
1076         std::vector<std::string> phoneticNameList = VCardUtils::ConstructListFromValue(propValue, vCardType_);
1077         HandlePhoneticNameFromSound(phoneticNameList);
1078     }
1079 }
1080 
1081 void VCardContact::AddPhotoDatas(std::string byte, std::string rawValue, std::string propValue,
1082     std::vector<std::string> values, std::map<std::string, std::vector<std::string>> parasMap)
1083 {
1084     std::vector<std::string> typeList;
1085     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
1086     if (it == parasMap.end()) {
1087         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
1088         return;
1089     } else {
1090         typeList = it->second;
1091     }
1092     std::string formatName;
1093     bool isPrimary = false;
1094     if (!typeList.empty()) {
1095         for (std::string typeValue : typeList) {
1096             if (typeValue == VCARD_PARAM_TYPE_PREF) {
1097                 isPrimary = true;
1098             } else if (formatName.empty()) {
1099                 formatName = typeValue;
1100             } else {
1101                 TELEPHONY_LOGI("No need to do anything");
1102             }
1103         }
1104     }
1105     AddPhotoBytes(formatName, byte, isPrimary);
1106 }
1107 
1108 void VCardContact::AddSkypePstnNumDatas(std::string propValue, std::map<std::string, std::vector<std::string>> parasMap)
1109 {
1110     std::vector<std::string> typeCollection;
1111     std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
1112     if (it == parasMap.end()) {
1113         TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
1114         return;
1115     } else {
1116         typeCollection = it->second;
1117     }
1118     int32_t type = static_cast<int32_t>(PhoneVcType::NUM_OTHER);
1119     bool isPrimary = false;
1120     if (std::find(typeCollection.begin(), typeCollection.end(), VCARD_PARAM_TYPE_PREF) != typeCollection.end()) {
1121         isPrimary = true;
1122     }
1123     AddPhone(type, propValue, "", isPrimary);
1124 }
1125 
1126 void VCardContact::AddWebSiteDatas(std::string rawValue, std::string propValue, std::vector<std::string> values,
1127     std::map<std::string, std::vector<std::string>> parasMap)
1128 {
1129     std::shared_ptr<VCardWebsiteData> object = std::make_shared<VCardWebsiteData>();
1130     std::vector<std::string> valueList = VCardUtils::Split((parasMap.size() != 0) ? propValue : rawValue, ";");
1131     object->InitWebsite((valueList.size() > SIZE_ZERO) ? valueList[VALUE_INDEX_ZERO] : "");
1132     object->SetLabelId((valueList.size() > SIZE_ONE) ? valueList[VALUE_INDEX_ONE] : "");
1133     object->SetLabelName((valueList.size() > SIZE_TWO) ? valueList[VALUE_INDEX_TWO] : "");
1134     websites_.push_back(object);
1135 }
1136 
1137 void VCardContact::AddBirthdayDatas(std::string rawValue)
1138 {
1139     std::shared_ptr<VCardBirthdayData> object = std::make_shared<VCardBirthdayData>();
1140     object->InitBirthdayData(rawValue);
1141     birthday_ = object;
1142 }
1143 
1144 void VCardContact::AddAnniversaryDatas(std::string propValue)
1145 {
1146     std::shared_ptr<VCardAnniversaryData> object = std::make_shared<VCardAnniversaryData>();
1147     object->InitAnniversaryData(propValue);
1148     anniversary_ = object;
1149 }
1150 
1151 void VCardContact::AddImppDatas(std::string propValue, std::map<std::string, std::vector<std::string>> parasMap)
1152 {
1153     if (VCardUtils::StartWith(propValue, "sip:")) {
1154         std::vector<std::string> typeCollection;
1155         std::map<std::string, std::vector<std::string>>::iterator it = parasMap.find(VCARD_PARAM_TYPE);
1156         if (it == parasMap.end()) {
1157             TELEPHONY_LOGE("Map does not contain this key, %{public}s", VCARD_PARAM_TYPE);
1158             return;
1159         } else {
1160             typeCollection = it->second;
1161         }
1162         HandleSipCase(propValue, typeCollection);
1163     }
1164 }
1165 
1166 void VCardContact::AddGroups(std::string rawValue)
1167 {
1168     std::shared_ptr<VCardGroupData> object = std::make_shared<VCardGroupData>();
1169     object->SetGroupName(rawValue);
1170     int groupId = VCardRdbHelper::QueryGroupId(rawValue);
1171     if (groupId < 0) {
1172         TELEPHONY_LOGE("query group Id for %{public}s failed", rawValue.c_str());
1173         return;
1174     }
1175     object->SetGroupId(groupId);
1176     groups_.push_back(object);
1177 }
1178 
1179 std::vector<std::string> VCardContact::GetValueListFromParasMap(
1180     std::string rawValue, std::string propValue, std::map<std::string, std::vector<std::string>> parasMap)
1181 {
1182     return VCardUtils::Split(((parasMap.size() == 0) ? rawValue : propValue), ";");
1183 }
1184 
1185 } // namespace Telephony
1186 } // namespace OHOS
1187