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