2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 * @file ContactWrapper.cpp
18 * @author Lukasz Marek(l.marek@samsung.com)
19 * @author Yujie Zeng(yj.zengk@samsung.com)
25 #include <dpl/log/log.h>
26 #include <Commons/Exception.h>
27 #include "ContactWrapper.h"
28 #include "AddressBook.h"
32 const char* CONTACT_ATTRIBUTE_PHONETIC_NAME = "phoneticName";
35 namespace WrtDeviceApis {
40 ContactWrapper::ContactWrapper(IAddressBookObject::BookType /*type*/) :
41 m_abstractContact(NULL),
42 m_platformContact(NULL)
45 //platform layer seems to not support different storage types yet
47 if ( type == IAddressBookObject::PhoneBook ) {
49 else if ( type == IAddressBookObject::SIMBook ) {
52 LogError("invalid storage type");
57 ContactWrapper::~ContactWrapper()
63 void ContactWrapper::freePlatformObject()
65 if (m_platformContact) {
66 contacts_svc_struct_free(m_platformContact);
67 m_platformContact = NULL;
71 void ContactWrapper::freeAbstractObject()
73 m_abstractContact = ContactPtr(NULL);
76 Api::ContactPtr ContactWrapper::getAbstractContact() const
78 return m_abstractContact;
81 void ContactWrapper::setAbstractContact(const ContactPtr &contact)
83 m_abstractContact = contact;
84 convertToPlatformObject();
87 CTSstruct* ContactWrapper::getPlatformContact() const
89 return m_platformContact;
92 void ContactWrapper::setPlatformContact(CTSstruct* contact)
95 m_platformContact = contact;
96 convertToAbstractObject();
99 bool ContactWrapper::convertToPlatformObject()
102 freePlatformObject();
103 if (!m_abstractContact) {
104 LogError("abstract object is not set");
107 //if abstrat object has id set then we have to read existing object and update it
108 if (m_abstractContact->getIdIsSet()) {
109 LogDebug("reading existing contact");
110 contacts_svc_get_contact(m_abstractContact->getId(), &m_platformContact);
112 //if no id is set then create new platform object
114 LogDebug("creating new contact");
115 m_platformContact = contacts_svc_struct_new(CTS_STRUCT_CONTACT);
117 if (!m_platformContact) {
118 LogError("contact structure not created properly");
124 if (!convertToPlatformBaseData()) {
125 ThrowMsg(Commons::UnknownException,
126 "error during converting base data");
129 if (!convertToPlatformAddressObject()) {
130 ThrowMsg(Commons::UnknownException,
131 "error during converting address object");
134 if (!convertToPlatformEmailObject()) {
135 ThrowMsg(Commons::UnknownException,
136 "error during converting email object");
139 if (!convertToPlatformPhoneObject()) {
140 ThrowMsg(Commons::UnknownException,
141 "error during converting phone object");
144 if (!convertToPlatformNicknameObject()) {
145 ThrowMsg(Commons::UnknownException,
146 "error during converting nickname object");
149 if (!convertToPlatformPhoneticnameObject()) {
150 ThrowMsg(Commons::UnknownException,
151 "error during converting Phoneticname object");
154 if (!convertToPlatformGroupObject()) {
155 ThrowMsg(Commons::UnknownException,
156 "error during converting group object");
159 catch (const Commons::UnknownException &ex)
161 LogError(ex.GetMessage());
162 freePlatformObject();
168 bool ContactWrapper::convertToAbstractObject()
171 freeAbstractObject();
172 if (!m_platformContact) {
175 CTSvalue *value = NULL;
178 contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE,
182 m_abstractContact = ContactPtr(new Contact());
183 m_abstractContact->setId(contacts_svc_value_get_int(
184 value, CTS_BASE_VAL_ID_INT));
185 const char *charValue = contacts_svc_value_get_str(
187 CTS_BASE_VAL_IMG_PATH_STR);
189 m_abstractContact->setPhotoUri(charValue);
191 charValue = contacts_svc_value_get_str(value,
192 CTS_BASE_VAL_RINGTONE_PATH_STR);
194 m_abstractContact->setRingTonePath(charValue);
198 //store base information
199 if (!convertToAbstractBaseData()) {
200 ThrowMsg(Commons::UnknownException,
201 "error during converting base data");
204 if (!convertToAbstractAddressObject()) {
205 ThrowMsg(Commons::UnknownException,
206 "error during converting address object");
209 if (!convertToAbstractEmailObject()) {
210 ThrowMsg(Commons::UnknownException,
211 "error during converting email object");
214 if (!convertToAbstractPhoneObject()) {
215 ThrowMsg(Commons::UnknownException,
216 "error during converting phone object");
219 if (!convertToAbstractNicknameObject()) {
220 ThrowMsg(Commons::UnknownException,
221 "error during converting nickname object");
224 if (!convertToAbstractPhoneticnameObject()) {
225 ThrowMsg(Commons::UnknownException,
226 "error during converting phoneticName object");
229 if (!convertToAbstractGroupObject()) {
230 ThrowMsg(Commons::UnknownException,
231 "error during converting group object");
234 catch (const Commons::UnknownException &ex)
236 LogError(ex.GetMessage());
237 freeAbstractObject();
243 bool ContactWrapper::convertToAbstractBaseData()
246 if (NULL == m_abstractContact) {
247 LogError("you should create empty abstract contact object first");
251 if (NULL == m_platformContact) {
252 LogError("you should provide platform contact object first");
256 CTSvalue *value = NULL;
258 const char *charValue = NULL;
259 errorCode = contacts_svc_struct_get_value(m_platformContact,
262 if (CTS_SUCCESS == errorCode) {
264 charValue = contacts_svc_value_get_str(value,
265 CTS_NAME_VAL_FIRST_STR);
267 m_abstractContact->setFirstName(charValue);
269 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_LAST_STR);
271 m_abstractContact->setLastName(charValue);
273 charValue = contacts_svc_value_get_str(value,
274 CTS_NAME_VAL_DISPLAY_STR);
276 m_abstractContact->setFullName(charValue);
278 charValue = contacts_svc_value_get_str(value,
279 CTS_NAME_VAL_PREFIX_STR);
281 m_abstractContact->setTitle(charValue);
286 } else if (CTS_ERR_NO_DATA != errorCode) {
290 errorCode = contacts_svc_struct_get_value(m_platformContact,
291 CTS_CF_COMPANY_VALUE,
293 if (CTS_SUCCESS == errorCode) {
295 charValue = contacts_svc_value_get_str(value,
296 CTS_COMPANY_VAL_NAME_STR);
298 m_abstractContact->setCompany(charValue);
303 } else if (CTS_ERR_NO_DATA != errorCode) {
309 bool ContactWrapper::convertToAbstractAddressObject()
312 if (NULL == m_abstractContact) {
313 LogError("you should create empty abstract contact object first");
317 if (NULL == m_platformContact) {
318 LogError("you should provide platform contact object first");
322 GSList *addressList = NULL;
323 const char *charValue = NULL;
324 std::vector<ContactAddressPtr> addresses;
325 int errorCode = contacts_svc_struct_get_list(m_platformContact,
326 CTS_CF_POSTAL_ADDR_LIST,
328 if (CTS_SUCCESS == errorCode) {
329 for (; addressList; addressList = g_slist_next(addressList)) {
330 ContactAddressPtr address(new ContactAddress());
331 addresses.push_back(address);
332 int type = contacts_svc_value_get_int(
333 static_cast<CTSvalue*>(addressList->data),
334 CTS_POSTAL_VAL_TYPE_INT);
335 //TODO "no enumeration for address type. Temporarly use email type"
337 case CTS_ADDR_TYPE_NONE:
338 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_PREF);
340 case CTS_ADDR_TYPE_HOME:
341 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_HOME);
343 case CTS_ADDR_TYPE_WORK:
344 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_WORK);
347 LogError("invalid address type");
348 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_PREF);
351 //TODO "no place to store: county, premises, additional information in platform struct"
353 charValue = contacts_svc_value_get_str(
354 static_cast<CTSvalue*>(addressList->data), );
356 address->setCounty(charValue);
358 charValue = contacts_svc_value_get_str(
359 static_cast<CTSvalue*>(addressList->data), );
361 address->setPremises(charValue);
363 charValue = contacts_svc_value_get_str(
364 static_cast<CTSvalue*>(addressList->data), );
366 address->setAdditionalInformation(charValue);
369 charValue = contacts_svc_value_get_str(
370 static_cast<CTSvalue*>(addressList->data),
371 CTS_POSTAL_VAL_COUNTRY_STR);
373 address->setCountry(charValue);
375 charValue = contacts_svc_value_get_str(
376 static_cast<CTSvalue*>(addressList->data),
377 CTS_POSTAL_VAL_REGION_STR);
379 address->setRegion(charValue);
381 charValue = contacts_svc_value_get_str(
382 static_cast<CTSvalue*>(addressList->data),
383 CTS_POSTAL_VAL_LOCALITY_STR);
385 address->setCity(charValue);
387 charValue = contacts_svc_value_get_str(
388 static_cast<CTSvalue*>(addressList->data),
389 CTS_POSTAL_VAL_STREET_STR);
391 address->setStreet(charValue);
393 charValue = contacts_svc_value_get_str(
394 static_cast<CTSvalue*>(addressList->data),
395 CTS_POSTAL_VAL_POBOX_STR);
397 address->setStreetNumber(charValue);
399 charValue = contacts_svc_value_get_str(
400 static_cast<CTSvalue*>(addressList->data),
401 CTS_POSTAL_VAL_POSTALCODE_STR);
403 address->setPostalCode(charValue);
405 charValue = contacts_svc_value_get_str(
406 static_cast<CTSvalue*>(addressList->data),
407 CTS_POSTAL_VAL_EXTENDED_STR);
409 address->setAddress(charValue);
412 } else if (CTS_ERR_NO_DATA != errorCode) {
415 m_abstractContact->setAddresses(addresses);
419 bool ContactWrapper::convertToAbstractEmailObject()
422 if (NULL == m_abstractContact) {
423 LogError("you should create empty abstract contact object first");
427 if (NULL == m_platformContact) {
428 LogError("you should provide platform contact object first");
432 GSList *emailList = NULL;
433 const char *charValue = NULL;
434 std::vector<ContactEmailPtr> emails;
435 int errorCode = contacts_svc_struct_get_list(m_platformContact,
438 if (CTS_SUCCESS == errorCode) {
439 for (; emailList; emailList = g_slist_next(emailList)) {
440 ContactEmailPtr email(new ContactEmail());
441 emails.push_back(email);
442 int type = contacts_svc_value_get_int(
443 static_cast<CTSvalue*>(emailList->data),
444 CTS_EMAIL_VAL_TYPE_INT);
446 case CTS_EMAIL_TYPE_NONE:
447 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_PREF);
449 case CTS_EMAIL_TYPE_HOME:
450 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_HOME);
452 case CTS_EMAIL_TYPE_WORK:
453 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_WORK);
456 LogError("invalid phone type");
457 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_PREF);
460 charValue = contacts_svc_value_get_str(
461 static_cast<CTSvalue*>(emailList->data),
462 CTS_EMAIL_VAL_ADDR_STR);
464 email->setEmail(charValue);
467 } else if (CTS_ERR_NO_DATA != errorCode) {
470 m_abstractContact->setEmails(emails);
474 bool ContactWrapper::convertToAbstractPhoneObject()
477 if (NULL == m_abstractContact) {
478 LogError("you should create empty abstract contact object first");
482 if (NULL == m_platformContact) {
483 LogError("you should provide platform contact object first");
487 GSList *phoneList = NULL;
488 const char *charValue = NULL;
489 std::vector<ContactPhoneNumberPtr> phoneNumbers;
490 int errorCode = contacts_svc_struct_get_list(m_platformContact,
493 if (CTS_SUCCESS == errorCode) {
494 for (; phoneList; phoneList = g_slist_next(phoneList)) {
495 ContactPhoneNumberPtr phoneNumber(new ContactPhoneNumber());
496 phoneNumbers.push_back(phoneNumber);
497 int type = contacts_svc_value_get_int(
498 static_cast<CTSvalue*>(phoneList->data),
499 CTS_NUM_VAL_TYPE_INT);
501 case CTS_NUM_TYPE_WORK:
502 phoneNumber->addType(
503 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_WORK);
505 case CTS_NUM_TYPE_NONE:
506 phoneNumber->addType(
507 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF);
509 case CTS_NUM_TYPE_HOME:
510 phoneNumber->addType(
511 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_HOME);
513 case CTS_NUM_TYPE_FAX:
514 phoneNumber->addType(
515 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_FAX);
517 case CTS_NUM_TYPE_CELL:
518 phoneNumber->addType(
519 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CELL);
521 case CTS_NUM_TYPE_PAGER:
522 phoneNumber->addType(
523 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PAGER);
525 case CTS_NUM_TYPE_CAR:
526 phoneNumber->addType(
527 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CAR);
529 case CTS_NUM_TYPE_VOICE:
530 phoneNumber->addType(
531 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VOICE);
533 case CTS_NUM_TYPE_MSG:
534 phoneNumber->addType(
535 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MSG);
537 case CTS_NUM_TYPE_BBS:
538 phoneNumber->addType(
539 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_BBS);
541 case CTS_NUM_TYPE_MODEM:
542 phoneNumber->addType(
543 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MODEM);
545 case CTS_NUM_TYPE_ISDN:
546 phoneNumber->addType(
547 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_ISDN);
549 case CTS_NUM_TYPE_VIDEO:
550 phoneNumber->addType(
551 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VIDEO);
553 case CTS_NUM_TYPE_PCS:
554 phoneNumber->addType(
555 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PCS);
558 LogError("invalid phone type");
559 phoneNumber->addType(
560 ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF);
563 charValue = contacts_svc_value_get_str(
564 static_cast<CTSvalue*>(phoneList->data),
565 CTS_NUM_VAL_NUMBER_STR);
567 phoneNumber->setNumber(charValue);
570 } else if (CTS_ERR_NO_DATA != errorCode) {
573 m_abstractContact->setPhoneNumbers(phoneNumbers);
577 bool ContactWrapper::convertToAbstractNicknameObject()
580 if (NULL == m_abstractContact) {
581 LogError("you should create empty abstract contact object first");
585 if (NULL == m_platformContact) {
586 LogError("you should provide platform contact object first");
590 GSList *nicknNameList = NULL;
591 const char *charValue = NULL;
592 std::vector<std::string> nickNames;
593 int errorCode = contacts_svc_struct_get_list(m_platformContact,
594 CTS_CF_NICKNAME_LIST,
596 if (CTS_SUCCESS == errorCode) {
597 for (; nicknNameList; nicknNameList = g_slist_next(nicknNameList)) {
598 charValue = contacts_svc_value_get_str(
599 static_cast<CTSvalue*>(nicknNameList->data),
600 CTS_NICKNAME_VAL_NAME_STR);
602 nickNames.push_back(charValue);
605 } else if (CTS_ERR_NO_DATA != errorCode) {
608 m_abstractContact->setNickNames(nickNames);
612 bool ContactWrapper::convertToAbstractPhoneticnameObject()
615 if (NULL == m_abstractContact) {
616 LogError("you should create empty abstract contact object first");
620 if (NULL == m_platformContact) {
621 LogError("you should provide platform contact object first");
625 CTSvalue *value = NULL;
627 int structFieldType = 0;
628 const char *charValue = NULL;
630 structFieldType = getCustomTypeInContactsSvc(
631 CONTACT_ATTRIBUTE_PHONETIC_NAME);
632 if (structFieldType < CTS_SUCCESS) {
633 LogError("Phonetic name struct type is not found!!");
638 contacts_svc_struct_get_value(m_platformContact,
639 static_cast<cts_struct_field>(
640 structFieldType), &value);
641 if (CTS_SUCCESS == errorCode) {
643 charValue = contacts_svc_value_get_str(value,
644 CTS_EXTEND_VAL_DATA2_STR);
646 m_abstractContact->setPhoneticName(charValue);
651 } else if (CTS_ERR_NO_DATA != errorCode) {
657 bool ContactWrapper::convertToAbstractGroupObject()
660 if (NULL == m_abstractContact) {
661 LogError("you should create empty abstract contact object first");
665 if (NULL == m_platformContact) {
666 LogError("you should provide platform contact object first");
670 GSList *groupList = NULL;
671 const char *charValue = NULL;
672 std::vector<std::string> groups;
673 int errorCode = contacts_svc_struct_get_list(m_platformContact,
674 CTS_CF_GROUPREL_LIST,
676 if (CTS_SUCCESS == errorCode) {
677 for (; groupList; groupList = g_slist_next(groupList)) {
678 charValue = contacts_svc_value_get_str(
679 static_cast<CTSvalue*>(groupList->data),
680 CTS_GROUPREL_VAL_NAME_STR);
682 groups.push_back(charValue);
685 } else if (CTS_ERR_NO_DATA != errorCode) {
688 m_abstractContact->setGroups(groups);
692 bool ContactWrapper::convertToPlatformNicknameObject()
695 if (NULL == m_abstractContact) {
696 LogError("you should create empty abstract contact object first");
700 if (NULL == m_platformContact) {
701 LogError("you should provide platform contact object first");
705 const std::vector<std::string> &nicknames =
706 m_abstractContact->getNickNames();
708 if (nicknames.size() == 0) {
712 CTSvalue *nickname = NULL;
713 bool properlyCreated = true;
714 GSList *nicknameList = NULL;
715 //mark existing items to delete them.
718 contacts_svc_struct_get_list(m_platformContact, CTS_CF_NICKNAME_LIST,
720 GSList *nicknameListSave = nicknameList;
721 for (; nicknameList; nicknameList = g_slist_next(nicknameList)) {
722 CTSvalue* nickname = static_cast<CTSvalue*>(nicknameList->data);
723 contacts_svc_value_set_bool(nickname,
724 CTS_NICKNAME_VAL_DELETE_BOOL,
727 nicknameList = nicknameListSave;
730 for (std::size_t i = 0; i < nicknames.size(); ++i) {
731 nickname = contacts_svc_value_new(CTS_VALUE_NICKNAME);
734 contacts_svc_value_set_str(nickname, CTS_NICKNAME_VAL_NAME_STR,
735 nicknames[i].c_str())) {
736 nicknameList = g_slist_append(nicknameList, nickname);
738 contacts_svc_value_free(nickname);
739 properlyCreated = false;
743 properlyCreated = false;
748 if (properlyCreated) {
750 contacts_svc_struct_store_list(m_platformContact,
751 CTS_CF_NICKNAME_LIST,
753 properlyCreated = false;
757 return properlyCreated;
760 bool ContactWrapper::convertToPlatformPhoneticnameObject()
763 if (NULL == m_abstractContact) {
764 LogError("you should create empty abstract contact object first");
768 if (NULL == m_platformContact) {
769 LogError("you should provide platform contact object first");
773 CTSvalue *value = NULL;
774 int structFieldType = 0;
776 structFieldType = getCustomTypeInContactsSvc(
777 CONTACT_ATTRIBUTE_PHONETIC_NAME);
778 if (structFieldType < CTS_SUCCESS) {
779 LogError("Phonetic name struct type is not found!!");
784 *If phonetic name information is not existed, add phonetic name information
785 *If phonetic name information is existed,update phonetic name information
788 contacts_svc_struct_get_value(m_platformContact,
789 static_cast<cts_struct_field>(
790 structFieldType), &value)) {
791 value = contacts_svc_value_new(CTS_VALUE_EXTEND);
797 contacts_svc_value_set_str(value, CTS_EXTEND_VAL_DATA2_STR,
798 m_abstractContact->getPhoneticName().c_str())
801 contacts_svc_struct_store_value(m_platformContact,
802 static_cast<cts_struct_field>(
803 structFieldType), value)) {
804 contacts_svc_value_free(value);
807 contacts_svc_value_free(value);
809 LogDebug("RETURN TRUE!!!");
813 bool ContactWrapper::convertToPlatformGroupObject()
816 if (NULL == m_abstractContact) {
817 LogError("you should create empty abstract contact object first");
821 if (NULL == m_platformContact) {
822 LogError("you should provide platform contact object first");
826 const std::vector<std::string> &groups =
827 m_abstractContact->getGroups();
828 if (groups.size() == 0) {
831 CTSvalue *group = NULL;
832 bool properlyCreated = true;
833 GSList *groupList = NULL;
834 //mark existing items to delete them.
836 contacts_svc_struct_get_list(m_platformContact, CTS_CF_GROUPREL_LIST,
838 GSList *groupListSave = groupList;
839 for (; groupList; groupList = g_slist_next(groupList)) {
840 LogDebug("clearing group list");
841 CTSvalue* delgroup = static_cast<CTSvalue*>(groupList->data);
842 contacts_svc_value_set_bool(delgroup,
843 CTS_GROUPREL_VAL_DELETE_BOOL,
846 groupList = groupListSave;
849 for (std::size_t i = 0; i < groups.size(); ++i) {
850 group = contacts_svc_value_new(CTS_VALUE_GROUP_RELATION);
853 //groupId = AddressBook::getGroupId(groups[i]);
855 CTSiter *iter = NULL;
857 contacts_svc_get_list(CTS_LIST_ALL_GROUP, &iter)) {
858 while (CTS_SUCCESS == contacts_svc_iter_next(iter)) {
859 CTSvalue *findgroup = contacts_svc_iter_get_info(iter);
861 const char *foundGroupName = contacts_svc_value_get_str(
863 CTS_LIST_GROUP_NAME_STR);
864 if (foundGroupName && groups[i] == foundGroupName) {
865 groupId = contacts_svc_value_get_int(
867 CTS_LIST_GROUP_ID_INT);
871 contacts_svc_iter_remove(iter);
873 LogDebug("group id " << groupId);
876 contacts_svc_value_set_int(group, CTS_GROUPREL_VAL_ID_INT,
878 groupList = g_slist_append(groupList, group);
880 contacts_svc_value_free(group);
881 properlyCreated = false;
885 contacts_svc_value_free(group);
886 properlyCreated = false;
890 properlyCreated = false;
894 if (properlyCreated) {
895 LogDebug("storing group list");
897 contacts_svc_struct_store_list(m_platformContact,
898 CTS_CF_GROUPREL_LIST,
900 properlyCreated = false;
903 for (; groupList; groupList = g_slist_next(groupList)) {
904 contacts_svc_value_free(static_cast<CTSvalue*>(groupList->data));
906 g_slist_free(groupList);
907 return properlyCreated;
910 bool ContactWrapper::convertToPlatformPhoneObject()
913 if (NULL == m_abstractContact) {
914 LogError("you should create empty abstract contact object first");
918 if (NULL == m_platformContact) {
919 LogError("you should provide platform contact object first");
924 const std::vector<ContactPhoneNumberPtr> &phoneNumbers =
925 m_abstractContact->getPhoneNumbers();
926 if (phoneNumbers.size() == 0) {
929 bool properlyCreated = true;
930 CTSvalue *number = NULL;
931 GSList *numberList = NULL;
932 //mark existing items to delete them.
934 contacts_svc_struct_get_list(m_platformContact, CTS_CF_NUMBER_LIST,
936 GSList *numberListSave = numberList;
937 for (; numberList; numberList = g_slist_next(numberList)) {
938 LogDebug("clearing phone list");
939 CTSvalue* number = static_cast<CTSvalue*>(numberList->data);
940 contacts_svc_value_set_bool(number, CTS_NUM_VAL_DELETE_BOOL, true);
942 numberList = numberListSave;
945 for (std::size_t i = 0; i < phoneNumbers.size(); ++i) {
946 std::vector<ContactPhoneNumber::ContactPhoneNumberType> types =
947 phoneNumbers[i]->getTypes();
948 for (std::size_t j = 0; j < types.size(); ++j)
950 number = contacts_svc_value_new(CTS_VALUE_NUMBER);
955 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_WORK:
956 type = CTS_NUM_TYPE_WORK;
958 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF:
959 type = CTS_NUM_TYPE_NONE;
961 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_HOME:
962 type = CTS_NUM_TYPE_HOME;
964 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_FAX:
965 type = CTS_NUM_TYPE_FAX;
967 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CELL:
968 type = CTS_NUM_TYPE_CELL;
970 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PAGER:
971 type = CTS_NUM_TYPE_PAGER;
973 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CAR:
974 type = CTS_NUM_TYPE_CAR;
976 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_BBS:
977 type = CTS_NUM_TYPE_BBS;
979 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MODEM:
980 type = CTS_NUM_TYPE_MODEM;
982 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_ISDN:
983 type = CTS_NUM_TYPE_ISDN;
985 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VIDEO:
986 type = CTS_NUM_TYPE_VIDEO;
988 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PCS:
989 type = CTS_NUM_TYPE_PCS;
991 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VOICE:
992 type = CTS_NUM_TYPE_VOICE;
994 case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MSG:
995 type = CTS_NUM_TYPE_MSG;
998 LogError("invalid phone type");
999 type = CTS_NUM_TYPE_NONE;
1005 type = CTS_NUM_TYPE_NONE;
1008 contacts_svc_value_set_str(number, CTS_NUM_VAL_NUMBER_STR,
1009 phoneNumbers[i]->getNumber().
1012 contacts_svc_value_set_bool(number,
1013 CTS_NUM_VAL_DEFAULT_BOOL,
1014 type == CTS_NUM_TYPE_NONE) &&
1016 contacts_svc_value_set_int(number, CTS_NUM_VAL_TYPE_INT,
1018 numberList = g_slist_append(numberList, number);
1020 contacts_svc_value_free(number);
1021 properlyCreated = false;
1025 properlyCreated = false;
1029 if (!properlyCreated) {
1033 if (properlyCreated) {
1035 contacts_svc_struct_store_list(m_platformContact,
1038 properlyCreated = false;
1041 for (; numberList; numberList = g_slist_next(numberList)) {
1042 contacts_svc_value_free(static_cast<CTSvalue*>(numberList->data));
1044 g_slist_free(numberList);
1045 return properlyCreated;
1048 bool ContactWrapper::convertToPlatformEmailObject()
1050 LogDebug("entered");
1051 if (NULL == m_abstractContact) {
1052 LogError("you should create empty abstract contact object first");
1056 if (NULL == m_platformContact) {
1057 LogError("you should provide platform contact object first");
1062 const std::vector<ContactEmailPtr> &emails =
1063 m_abstractContact->getEmails();
1064 if (emails.size() == 0) {
1067 CTSvalue *email = NULL;
1068 bool properlyCreated = true;
1069 GSList *emailList = NULL;
1070 //mark existing items to delete them.
1072 contacts_svc_struct_get_list(m_platformContact, CTS_CF_EMAIL_LIST,
1074 GSList *emailListSave = emailList;
1075 for (; emailList; emailList = g_slist_next(emailList)) {
1076 LogDebug("clearing email list");
1077 CTSvalue* email = static_cast<CTSvalue*>(emailList->data);
1078 contacts_svc_value_set_bool(email, CTS_EMAIL_VAL_DELETE_BOOL, true);
1080 emailList = emailListSave;
1083 for (std::size_t i = 0; i < emails.size(); ++i) {
1084 std::vector<ContactEmail::ContactEmailType> types =
1085 emails[i]->getTypes();
1086 for (std::size_t j = 0; j < types.size(); ++j)
1088 email = contacts_svc_value_new(CTS_VALUE_EMAIL);
1091 if(types.size() > 0)
1094 case ContactEmail::CONTACT_EMAIL_TYPE_HOME:
1095 type = CTS_EMAIL_TYPE_HOME;
1097 case ContactEmail::CONTACT_EMAIL_TYPE_WORK:
1098 type = CTS_EMAIL_TYPE_WORK;
1100 case ContactEmail::CONTACT_EMAIL_TYPE_PREF:
1101 type = CTS_EMAIL_TYPE_NONE;
1104 LogError("invalid phone type");
1105 type = CTS_EMAIL_TYPE_NONE;
1111 type = CTS_EMAIL_TYPE_NONE;
1114 contacts_svc_value_set_int(email, CTS_EMAIL_VAL_TYPE_INT,
1117 contacts_svc_value_set_str(email, CTS_EMAIL_VAL_ADDR_STR,
1118 emails[i]->getEmail().c_str()))
1120 emailList = g_slist_append(emailList, email);
1122 contacts_svc_value_free(email);
1123 properlyCreated = false;
1129 properlyCreated = false;
1134 if (!properlyCreated) {
1138 if (properlyCreated) {
1140 contacts_svc_struct_store_list(m_platformContact, CTS_CF_EMAIL_LIST,
1142 properlyCreated = false;
1145 for (; emailList; emailList = g_slist_next(emailList)) {
1146 contacts_svc_value_free(static_cast<CTSvalue*>(emailList->data));
1148 g_slist_free(emailList);
1149 return properlyCreated;
1152 bool ContactWrapper::convertToPlatformAddressObject()
1154 LogDebug("entered");
1155 if (NULL == m_abstractContact) {
1156 LogError("you should create empty abstract contact object first");
1160 if (NULL == m_platformContact) {
1161 LogError("you should provide platform contact object first");
1166 const std::vector<ContactAddressPtr> &addresses =
1167 m_abstractContact->getAddresses();
1168 if (addresses.size() == 0) {
1171 CTSvalue *address = NULL;
1172 bool properlyCreated = true;
1173 GSList *addressList = NULL;
1174 //mark existing items to delete them.
1176 contacts_svc_struct_get_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST,
1178 GSList *addressListSave = addressList;
1179 for (; addressList; addressList = g_slist_next(addressList)) {
1180 LogDebug("clearing address list");
1181 CTSvalue* address = static_cast<CTSvalue*>(addressList->data);
1182 contacts_svc_value_set_bool(address,
1183 CTS_POSTAL_VAL_DELETE_BOOL,
1186 addressList = addressListSave;
1189 for (std::size_t i = 0; i < addresses.size(); ++i) {
1190 std::vector<ContactAddress::ContactAddressType> types =
1191 addresses[i]->getTypes();
1192 for (std::size_t j = 0; j < types.size(); ++j) {
1193 address = contacts_svc_value_new(CTS_VALUE_POSTAL);
1195 //TODO "no place to store: county, premises, additional information in platform struct"
1197 case ContactAddress::CONTACT_ADDRESS_TYPE_PREF:
1198 type = CTS_ADDR_TYPE_NONE;
1200 case ContactAddress::CONTACT_ADDRESS_TYPE_WORK:
1201 type = CTS_ADDR_TYPE_WORK;
1203 case ContactAddress::CONTACT_ADDRESS_TYPE_HOME:
1204 type = CTS_ADDR_TYPE_HOME;
1207 LogError("invalid address type");
1208 type = CTS_EMAIL_TYPE_NONE;
1211 //CTS_SUCCESS == contacts_svc_value_set_str(address, , addresses[i]->getCounty().c_str()) &&
1212 //CTS_SUCCESS == contacts_svc_value_set_str(address, , addresses[i]->getPremises().c_str()) &&
1213 //CTS_SUCCESS == contacts_svc_value_set_str(address, , addresses[i]->getAdditionalInformation().c_str()) &&
1215 contacts_svc_value_set_int(address, CTS_POSTAL_VAL_TYPE_INT,
1218 contacts_svc_value_set_str(address,
1219 CTS_POSTAL_VAL_COUNTRY_STR,
1220 addresses[i]->getCountry().c_str())
1223 contacts_svc_value_set_str(address,
1224 CTS_POSTAL_VAL_REGION_STR,
1225 addresses[i]->getRegion().c_str())
1228 contacts_svc_value_set_str(address,
1229 CTS_POSTAL_VAL_LOCALITY_STR,
1230 addresses[i]->getCity().c_str())
1233 contacts_svc_value_set_str(address,
1234 CTS_POSTAL_VAL_STREET_STR,
1235 addresses[i]->getStreet().c_str())
1238 contacts_svc_value_set_str(address,
1239 CTS_POSTAL_VAL_POBOX_STR,
1240 addresses[i]->getStreetNumber().
1243 contacts_svc_value_set_str(address,
1244 CTS_POSTAL_VAL_POSTALCODE_STR,
1245 addresses[i]->getPostalCode().
1248 contacts_svc_value_set_str(address,
1249 CTS_POSTAL_VAL_EXTENDED_STR,
1251 getAdditionalInformation().
1253 addressList = g_slist_append(addressList, address);
1255 contacts_svc_value_free(address);
1256 properlyCreated = false;
1260 properlyCreated = false;
1264 if (!properlyCreated) {
1268 if (properlyCreated) {
1270 contacts_svc_struct_store_list(m_platformContact,
1271 CTS_CF_POSTAL_ADDR_LIST,
1273 properlyCreated = false;
1276 for (; addressList; addressList = g_slist_next(addressList)) {
1277 contacts_svc_value_free(static_cast<CTSvalue*>(addressList->data));
1279 g_slist_free(addressList);
1280 return properlyCreated;
1283 bool ContactWrapper::convertToPlatformBaseData()
1285 LogDebug("entered");
1286 if (NULL == m_abstractContact) {
1287 LogError("you should create empty abstract contact object first");
1291 if (NULL == m_platformContact) {
1292 LogError("you should provide platform contact object first");
1297 *If name information is not existed, add name information
1298 * If name information is existed,update name information
1300 CTSvalue *value = NULL;
1303 contacts_svc_struct_get_value(m_platformContact, CTS_CF_NAME_VALUE,
1305 CTSvalue *value = contacts_svc_value_new(CTS_VALUE_NAME);
1308 contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR,
1309 m_abstractContact->getFirstName().
1312 contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR,
1313 m_abstractContact->getLastName().
1316 contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR,
1317 m_abstractContact->getFullName().
1320 contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR,
1321 m_abstractContact->getTitle().c_str())
1324 contacts_svc_struct_store_value(m_platformContact,
1325 CTS_CF_NAME_VALUE, value)) {
1326 contacts_svc_value_free(value);
1329 contacts_svc_value_free(value);
1335 contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR,
1336 m_abstractContact->getFirstName().c_str())
1339 contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR,
1340 m_abstractContact->getLastName().c_str())
1343 contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR,
1344 m_abstractContact->getFullName().c_str())
1347 contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR,
1348 m_abstractContact->getTitle().c_str()))
1350 contacts_svc_value_free(value);
1353 contacts_svc_value_free(value);
1357 *If photo and ringtone uri information is not existed, add the information
1358 * If photo and ringtone uri is existed,update the information
1360 CTSvalue *baseinfo = NULL;
1362 contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE,
1364 baseinfo = contacts_svc_value_new(CTS_VALUE_CONTACT_BASE_INFO);
1366 if (m_abstractContact->getPhotoIsSet()) {
1368 contacts_svc_value_set_str(baseinfo,
1369 CTS_BASE_VAL_IMG_PATH_STR,
1370 m_abstractContact->getPhotoUri()
1372 contacts_svc_value_free(baseinfo);
1377 contacts_svc_value_set_str(baseinfo,
1378 CTS_BASE_VAL_RINGTONE_PATH_STR,
1379 m_abstractContact->getRingTonePath()
1382 contacts_svc_struct_store_value(m_platformContact,
1383 CTS_CF_BASE_INFO_VALUE,
1385 contacts_svc_value_free(baseinfo);
1389 contacts_svc_value_free(baseinfo);
1394 const char * oldimgpath = NULL;
1395 oldimgpath = contacts_svc_value_get_str(baseinfo,
1396 CTS_BASE_VAL_IMG_PATH_STR);
1398 std::string stroldimgpath = "";
1399 if (NULL != oldimgpath) {
1400 stroldimgpath = static_cast<std::string>(oldimgpath);
1403 std::string strnewimgpath = m_abstractContact->getPhotoUri();
1404 if (stroldimgpath != strnewimgpath) {
1406 contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR,
1407 strnewimgpath.c_str())) {
1408 contacts_svc_value_free(value);
1414 contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR,
1415 m_abstractContact->getRingTonePath().
1419 contacts_svc_value_free(value);
1422 //save company information
1423 CTSvalue *company = NULL;
1424 company = contacts_svc_value_new(CTS_VALUE_COMPANY);
1427 contacts_svc_value_set_str(company, CTS_COMPANY_VAL_NAME_STR,
1428 m_abstractContact->getCompany().c_str())
1431 contacts_svc_struct_store_value(m_platformContact,
1432 CTS_CF_COMPANY_VALUE,
1434 contacts_svc_value_free(company);
1437 contacts_svc_value_free(value);
1445 int ContactWrapper::getCustomTypeInContactsSvc(const std::string &typeName)
1448 int structFieldType = -1;
1450 LogDebug("typeName : " << typeName);
1451 structFieldType = contacts_svc_find_custom_type(CTS_TYPE_CLASS_EXTEND_DATA,
1452 const_cast<char*>(typeName.
1454 if (CTS_ERR_DB_RECORD_NOT_FOUND == structFieldType) {
1455 LogDebug("CTS_ERR_DB_RECORD_NOT_FOUND!!");
1456 structFieldType = contacts_svc_insert_custom_type(
1457 CTS_TYPE_CLASS_EXTEND_DATA,
1458 const_cast<char*>(typeName.c_str()));
1459 if (CTS_SUCCESS > structFieldType) {
1460 LogDebug("Create fail");
1462 } else if (CTS_SUCCESS > structFieldType) {
1463 LogDebug("contacts_svc_find_custom_type is fail");
1466 LogDebug("structFieldType : " << structFieldType);
1467 return structFieldType;
1470 void ContactWrapper::printPlatformObject()
1472 LogDebug("entered");
1475 void ContactWrapper::printAbstractObject()
1477 LogDebug("entered");