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