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