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