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