src/modules/tizen/Contact/ContactWrapper.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 /**
  17  * @file        ContactWrapper.cpp
  18  * @author      Lukasz Marek(l.marek@samsung.com)
  19  * @author      Yujie Zeng(yj.zengk@samsung.com)
  20  * @version     0.1
  21  */
  22
  23 #include <vector>
  24 #include <pcrecpp.h>
  25 #include <dpl/log/log.h>
  26 #include <Commons/Exception.h>
  27 #include "ContactWrapper.h"
  28 #include "AddressBook.h"
  29
  30 namespace {
  31 // Custom Type Name
  32 const char* CONTACT_ATTRIBUTE_PHONETIC_NAME = "phoneticName";
  33 }
  34
  35 namespace WrtDeviceApis {
  36 namespace Contact {
  37
  38 using namespace Api;
  39
  40 ContactWrapper::ContactWrapper(IAddressBookObject::BookType /*type*/) :
  41     m_abstractContact(NULL),
  42     m_platformContact(NULL)
  43 {
  44     LogDebug("entered");
  45     //platform layer seems to not support different storage types yet
  46     /*
  47        if ( type == IAddressBookObject::PhoneBook ) {
  48        }
  49        else if ( type == IAddressBookObject::SIMBook ) {
  50        }
  51        else {
  52         LogError("invalid storage type");
  53        }
  54      */
  55 }
  56
  57 ContactWrapper::~ContactWrapper()
  58 {
  59     LogDebug("entered");
  60     freePlatformObject();
  61 }
  62
  63 void ContactWrapper::freePlatformObject()
  64 {
  65     if (m_platformContact) {
  66         contacts_svc_struct_free(m_platformContact);
  67         m_platformContact = NULL;
  68     }
  69 }
  70
  71 void ContactWrapper::freeAbstractObject()
  72 {
  73     m_abstractContact = ContactPtr(NULL);
  74 }
  75
  76 Api::ContactPtr ContactWrapper::getAbstractContact() const
  77 {
  78     return m_abstractContact;
  79 }
  80
  81 void ContactWrapper::setAbstractContact(const ContactPtr &contact)
  82 {
  83     m_abstractContact = contact;
  84     convertToPlatformObject();
  85 }
  86
  87 CTSstruct* ContactWrapper::getPlatformContact() const
  88 {
  89     return m_platformContact;
  90 }
  91
  92 void ContactWrapper::setPlatformContact(CTSstruct* contact)
  93 {
  94     freePlatformObject();
  95     m_platformContact = contact;
  96     convertToAbstractObject();
  97 }
  98
  99 bool ContactWrapper::convertToPlatformObject()
 100 {
 101     LogDebug("entered");
 102     freePlatformObject();
 103     if (!m_abstractContact) {
 104         LogError("abstract object is not set");
 105         return false;
 106     }
 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);
 111     }
 112     //if no id is set then create new platform object
 113     else {
 114         LogDebug("creating new contact");
 115         m_platformContact = contacts_svc_struct_new(CTS_STRUCT_CONTACT);
 116     }
 117     if (!m_platformContact) {
 118         LogError("contact structure not created properly");
 119         return false;
 120     }
 121     try
 122     {
 123         //store name
 124         if (!convertToPlatformBaseData()) {
 125             ThrowMsg(Commons::UnknownException,
 126                      "error during converting base data");
 127         }
 128         //store address
 129         if (!convertToPlatformAddressObject()) {
 130             ThrowMsg(Commons::UnknownException,
 131                      "error during converting address object");
 132         }
 133         //store email
 134         if (!convertToPlatformEmailObject()) {
 135             ThrowMsg(Commons::UnknownException,
 136                      "error during converting email object");
 137         }
 138         //store phone
 139         if (!convertToPlatformPhoneObject()) {
 140             ThrowMsg(Commons::UnknownException,
 141                      "error during converting phone object");
 142         }
 143         //nickname
 144         if (!convertToPlatformNicknameObject()) {
 145             ThrowMsg(Commons::UnknownException,
 146                      "error during converting nickname object");
 147         }
 148         //phoneticName
 149         if (!convertToPlatformPhoneticnameObject()) {
 150             ThrowMsg(Commons::UnknownException,
 151                      "error during converting Phoneticname object");
 152         }
 153         //group
 154         if (!convertToPlatformGroupObject()) {
 155             ThrowMsg(Commons::UnknownException,
 156                      "error during converting group object");
 157         }
 158     }
 159     catch (const Commons::UnknownException &ex)
 160     {
 161         LogError(ex.GetMessage());
 162         freePlatformObject();
 163         return false;
 164     }
 165     return true;
 166 }
 167
 168 bool ContactWrapper::convertToAbstractObject()
 169 {
 170     LogDebug("entered");
 171     freeAbstractObject();
 172     if (!m_platformContact) {
 173         return false;
 174     }
 175     CTSvalue *value = NULL;
 176     //store id
 177     if (CTS_SUCCESS !=
 178         contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE,
 179                                       &value)) {
 180         return false;
 181     }
 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(
 186             value,
 187             CTS_BASE_VAL_IMG_PATH_STR);
 188     if (charValue) {
 189         m_abstractContact->setPhotoUri(charValue);
 190     }
 191     charValue = contacts_svc_value_get_str(value,
 192                                            CTS_BASE_VAL_RINGTONE_PATH_STR);
 193     if (charValue) {
 194         m_abstractContact->setRingTonePath(charValue);
 195     }
 196     try
 197     {
 198         //store base information
 199         if (!convertToAbstractBaseData()) {
 200             ThrowMsg(Commons::UnknownException,
 201                      "error during converting base data");
 202         }
 203         //store address
 204         if (!convertToAbstractAddressObject()) {
 205             ThrowMsg(Commons::UnknownException,
 206                      "error during converting address object");
 207         }
 208         //store email
 209         if (!convertToAbstractEmailObject()) {
 210             ThrowMsg(Commons::UnknownException,
 211                      "error during converting email object");
 212         }
 213         //store phone
 214         if (!convertToAbstractPhoneObject()) {
 215             ThrowMsg(Commons::UnknownException,
 216                      "error during converting phone object");
 217         }
 218         //nickname
 219         if (!convertToAbstractNicknameObject()) {
 220             ThrowMsg(Commons::UnknownException,
 221                      "error during converting nickname object");
 222         }
 223         //phoneticName
 224         if (!convertToAbstractPhoneticnameObject()) {
 225             ThrowMsg(Commons::UnknownException,
 226                      "error during converting phoneticName object");
 227         }
 228         //group
 229         if (!convertToAbstractGroupObject()) {
 230             ThrowMsg(Commons::UnknownException,
 231                      "error during converting group object");
 232         }
 233     }
 234     catch (const Commons::UnknownException &ex)
 235     {
 236         LogError(ex.GetMessage());
 237         freeAbstractObject();
 238         return false;
 239     }
 240     return true;
 241 }
 242
 243 bool ContactWrapper::convertToAbstractBaseData()
 244 {
 245     LogDebug("entered");
 246     if (NULL == m_abstractContact) {
 247         LogError("you should create empty abstract contact object first");
 248         return false;
 249     }
 250
 251     if (NULL == m_platformContact) {
 252         LogError("you should provide platform contact object first");
 253         return false;
 254     }
 255
 256     CTSvalue *value = NULL;
 257     int errorCode;
 258     const char *charValue = NULL;
 259     errorCode = contacts_svc_struct_get_value(m_platformContact,
 260                                               CTS_CF_NAME_VALUE,
 261                                               &value);
 262     if (CTS_SUCCESS == errorCode) {
 263         if (value) {
 264             charValue = contacts_svc_value_get_str(value,
 265                                                    CTS_NAME_VAL_FIRST_STR);
 266             if (charValue) {
 267                 m_abstractContact->setFirstName(charValue);
 268             }
 269             charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_LAST_STR);
 270             if (charValue) {
 271                 m_abstractContact->setLastName(charValue);
 272             }
 273             charValue = contacts_svc_value_get_str(value,
 274                                                    CTS_NAME_VAL_DISPLAY_STR);
 275             if (charValue) {
 276                 m_abstractContact->setFullName(charValue);
 277             }
 278             charValue = contacts_svc_value_get_str(value,
 279                                                    CTS_NAME_VAL_PREFIX_STR);
 280             if (charValue) {
 281                 m_abstractContact->setTitle(charValue);
 282             }
 283         } else {
 284             return false;
 285         }
 286     } else if (CTS_ERR_NO_DATA != errorCode) {
 287         return false;
 288     }
 289     value = NULL;
 290     errorCode = contacts_svc_struct_get_value(m_platformContact,
 291                                               CTS_CF_COMPANY_VALUE,
 292                                               &value);
 293     if (CTS_SUCCESS == errorCode) {
 294         if (value) {
 295             charValue = contacts_svc_value_get_str(value,
 296                                                    CTS_COMPANY_VAL_NAME_STR);
 297             if (charValue) {
 298                 m_abstractContact->setCompany(charValue);
 299             }
 300         } else {
 301             return false;
 302         }
 303     } else if (CTS_ERR_NO_DATA != errorCode) {
 304         return false;
 305     }
 306     return true;
 307 }
 308
 309 bool ContactWrapper::convertToAbstractAddressObject()
 310 {
 311     LogDebug("entered");
 312     if (NULL == m_abstractContact) {
 313         LogError("you should create empty abstract contact object first");
 314         return false;
 315     }
 316
 317     if (NULL == m_platformContact) {
 318         LogError("you should provide platform contact object first");
 319         return false;
 320     }
 321
 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,
 327                                                  &addressList);
 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"
 336             switch (type) {
 337             case CTS_ADDR_TYPE_NONE:
 338                 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_PREF);
 339                 break;
 340             case CTS_ADDR_TYPE_HOME:
 341                 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_HOME);
 342                 break;
 343             case CTS_ADDR_TYPE_WORK:
 344                 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_WORK);
 345                 break;
 346             default:
 347                 LogError("invalid address type");
 348                 address->addType(ContactAddress::CONTACT_ADDRESS_TYPE_PREF);
 349                 break;
 350             }
 351             //TODO "no place to store: county, premises, additional information in platform struct"
 352     #if 0
 353             charValue = contacts_svc_value_get_str(
 354                     static_cast<CTSvalue*>(addressList->data), );
 355             if (charValue) {
 356                 address->setCounty(charValue);
 357             }
 358             charValue = contacts_svc_value_get_str(
 359                     static_cast<CTSvalue*>(addressList->data), );
 360             if (charValue) {
 361                 address->setPremises(charValue);
 362             }
 363             charValue = contacts_svc_value_get_str(
 364                     static_cast<CTSvalue*>(addressList->data), );
 365             if (charValue) {
 366                 address->setAdditionalInformation(charValue);
 367             }
 368     #endif
 369             charValue = contacts_svc_value_get_str(
 370                     static_cast<CTSvalue*>(addressList->data),
 371                     CTS_POSTAL_VAL_COUNTRY_STR);
 372             if (charValue) {
 373                 address->setCountry(charValue);
 374             }
 375             charValue = contacts_svc_value_get_str(
 376                     static_cast<CTSvalue*>(addressList->data),
 377                     CTS_POSTAL_VAL_REGION_STR);
 378             if (charValue) {
 379                 address->setRegion(charValue);
 380             }
 381             charValue = contacts_svc_value_get_str(
 382                     static_cast<CTSvalue*>(addressList->data),
 383                     CTS_POSTAL_VAL_LOCALITY_STR);
 384             if (charValue) {
 385                 address->setCity(charValue);
 386             }
 387             charValue = contacts_svc_value_get_str(
 388                     static_cast<CTSvalue*>(addressList->data),
 389                     CTS_POSTAL_VAL_STREET_STR);
 390             if (charValue) {
 391                 address->setStreet(charValue);
 392             }
 393             charValue = contacts_svc_value_get_str(
 394                     static_cast<CTSvalue*>(addressList->data),
 395                     CTS_POSTAL_VAL_POBOX_STR);
 396             if (charValue) {
 397                 address->setStreetNumber(charValue);
 398             }
 399             charValue = contacts_svc_value_get_str(
 400                     static_cast<CTSvalue*>(addressList->data),
 401                     CTS_POSTAL_VAL_POSTALCODE_STR);
 402             if (charValue) {
 403                 address->setPostalCode(charValue);
 404             }
 405             charValue = contacts_svc_value_get_str(
 406                     static_cast<CTSvalue*>(addressList->data),
 407                     CTS_POSTAL_VAL_EXTENDED_STR);
 408             if (charValue) {
 409                 address->setAddress(charValue);
 410             }
 411         }
 412     } else if (CTS_ERR_NO_DATA != errorCode) {
 413         return false;
 414     }
 415     m_abstractContact->setAddresses(addresses);
 416     return true;
 417 }
 418
 419 bool ContactWrapper::convertToAbstractEmailObject()
 420 {
 421     LogDebug("entered");
 422     if (NULL == m_abstractContact) {
 423         LogError("you should create empty abstract contact object first");
 424         return false;
 425     }
 426
 427     if (NULL == m_platformContact) {
 428         LogError("you should provide platform contact object first");
 429         return false;
 430     }
 431
 432     GSList *emailList = NULL;
 433     const char *charValue = NULL;
 434     std::vector<ContactEmailPtr> emails;
 435     int errorCode = contacts_svc_struct_get_list(m_platformContact,
 436                                                  CTS_CF_EMAIL_LIST,
 437                                                  &emailList);
 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);
 445             switch (type) {
 446             case CTS_EMAIL_TYPE_NONE:
 447                 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_PREF);
 448                 break;
 449             case CTS_EMAIL_TYPE_HOME:
 450                 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_HOME);
 451                 break;
 452             case CTS_EMAIL_TYPE_WORK:
 453                 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_WORK);
 454                 break;
 455             default:
 456                 LogError("invalid phone type");
 457                 email->addType(ContactEmail::CONTACT_EMAIL_TYPE_PREF);
 458                 break;
 459             }
 460             charValue = contacts_svc_value_get_str(
 461                     static_cast<CTSvalue*>(emailList->data),
 462                     CTS_EMAIL_VAL_ADDR_STR);
 463             if (charValue) {
 464                 email->setEmail(charValue);
 465             }
 466         }
 467     } else if (CTS_ERR_NO_DATA != errorCode) {
 468         return false;
 469     }
 470     m_abstractContact->setEmails(emails);
 471     return true;
 472 }
 473
 474 bool ContactWrapper::convertToAbstractPhoneObject()
 475 {
 476     LogDebug("entered");
 477     if (NULL == m_abstractContact) {
 478         LogError("you should create empty abstract contact object first");
 479         return false;
 480     }
 481
 482     if (NULL == m_platformContact) {
 483         LogError("you should provide platform contact object first");
 484         return false;
 485     }
 486
 487     GSList *phoneList = NULL;
 488     const char *charValue = NULL;
 489     std::vector<ContactPhoneNumberPtr> phoneNumbers;
 490     int errorCode = contacts_svc_struct_get_list(m_platformContact,
 491                                                  CTS_CF_NUMBER_LIST,
 492                                                  &phoneList);
 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);
 500             switch (type) {
 501             case CTS_NUM_TYPE_WORK:
 502                 phoneNumber->addType(
 503                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_WORK);
 504                 break;
 505             case CTS_NUM_TYPE_NONE:
 506                 phoneNumber->addType(
 507                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF);
 508                 break;
 509             case CTS_NUM_TYPE_HOME:
 510                 phoneNumber->addType(
 511                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_HOME);
 512                 break;
 513             case CTS_NUM_TYPE_FAX:
 514                 phoneNumber->addType(
 515                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_FAX);
 516                 break;
 517             case CTS_NUM_TYPE_CELL:
 518                 phoneNumber->addType(
 519                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CELL);
 520                 break;
 521             case CTS_NUM_TYPE_PAGER:
 522                 phoneNumber->addType(
 523                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PAGER);
 524                 break;
 525             case CTS_NUM_TYPE_CAR:
 526                 phoneNumber->addType(
 527                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CAR);
 528                 break;
 529             case CTS_NUM_TYPE_VOICE:
 530                 phoneNumber->addType(
 531                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VOICE);
 532                 break;
 533             case CTS_NUM_TYPE_MSG:
 534                 phoneNumber->addType(
 535                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MSG);
 536                 break;
 537             case CTS_NUM_TYPE_BBS:
 538                 phoneNumber->addType(
 539                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_BBS);
 540                 break;
 541             case CTS_NUM_TYPE_MODEM:
 542                 phoneNumber->addType(
 543                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MODEM);
 544                 break;
 545             case CTS_NUM_TYPE_ISDN:
 546                 phoneNumber->addType(
 547                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_ISDN);
 548                 break;
 549             case CTS_NUM_TYPE_VIDEO:
 550                 phoneNumber->addType(
 551                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VIDEO);
 552                 break;
 553             case CTS_NUM_TYPE_PCS:
 554                 phoneNumber->addType(
 555                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PCS);
 556                 break;
 557             default:
 558                 LogError("invalid phone type");
 559                 phoneNumber->addType(
 560                     ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF);
 561                 break;
 562             }
 563             charValue = contacts_svc_value_get_str(
 564                     static_cast<CTSvalue*>(phoneList->data),
 565                     CTS_NUM_VAL_NUMBER_STR);
 566             if (charValue) {
 567                 phoneNumber->setNumber(charValue);
 568             }
 569         }
 570     } else if (CTS_ERR_NO_DATA != errorCode) {
 571         return false;
 572     }
 573     m_abstractContact->setPhoneNumbers(phoneNumbers);
 574     return true;
 575 }
 576
 577 bool ContactWrapper::convertToAbstractNicknameObject()
 578 {
 579     LogDebug("entered");
 580     if (NULL == m_abstractContact) {
 581         LogError("you should create empty abstract contact object first");
 582         return false;
 583     }
 584
 585     if (NULL == m_platformContact) {
 586         LogError("you should provide platform contact object first");
 587         return false;
 588     }
 589
 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,
 595                                                  &nicknNameList);
 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);
 601             if (charValue) {
 602                 nickNames.push_back(charValue);
 603             }
 604         }
 605     } else if (CTS_ERR_NO_DATA != errorCode) {
 606         return false;
 607     }
 608     m_abstractContact->setNickNames(nickNames);
 609     return true;
 610 }
 611
 612 bool ContactWrapper::convertToAbstractPhoneticnameObject()
 613 {
 614     LogDebug("entered");
 615     if (NULL == m_abstractContact) {
 616         LogError("you should create empty abstract contact object first");
 617         return false;
 618     }
 619
 620     if (NULL == m_platformContact) {
 621         LogError("you should provide platform contact object first");
 622         return false;
 623     }
 624
 625     CTSvalue *value = NULL;
 626     int errorCode;
 627     int structFieldType = 0;
 628     const char *charValue = NULL;
 629
 630     structFieldType = getCustomTypeInContactsSvc(
 631             CONTACT_ATTRIBUTE_PHONETIC_NAME);
 632     if (structFieldType < CTS_SUCCESS) {
 633         LogError("Phonetic name struct type is not found!!");
 634         return false;
 635     }
 636
 637     errorCode =
 638         contacts_svc_struct_get_value(m_platformContact,
 639                                       static_cast<cts_struct_field>(
 640                                           structFieldType), &value);
 641     if (CTS_SUCCESS == errorCode) {
 642         if (value) {
 643             charValue = contacts_svc_value_get_str(value,
 644                                                    CTS_EXTEND_VAL_DATA2_STR);
 645             if (charValue) {
 646                 m_abstractContact->setPhoneticName(charValue);
 647             }
 648         } else {
 649             return false;
 650         }
 651     } else if (CTS_ERR_NO_DATA != errorCode) {
 652         return false;
 653     }
 654     return true;
 655 }
 656
 657 bool ContactWrapper::convertToAbstractGroupObject()
 658 {
 659     LogDebug("entered");
 660     if (NULL == m_abstractContact) {
 661         LogError("you should create empty abstract contact object first");
 662         return false;
 663     }
 664
 665     if (NULL == m_platformContact) {
 666         LogError("you should provide platform contact object first");
 667         return false;
 668     }
 669
 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,
 675                                                  &groupList);
 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);
 681             if (charValue) {
 682                 groups.push_back(charValue);
 683             }
 684         }
 685     } else if (CTS_ERR_NO_DATA != errorCode) {
 686         return false;
 687     }
 688     m_abstractContact->setGroups(groups);
 689     return true;
 690 }
 691
 692 bool ContactWrapper::convertToPlatformNicknameObject()
 693 {
 694     LogDebug("entered");
 695     if (NULL == m_abstractContact) {
 696         LogError("you should create empty abstract contact object first");
 697         return false;
 698     }
 699
 700     if (NULL == m_platformContact) {
 701         LogError("you should provide platform contact object first");
 702         return false;
 703     }
 704
 705     const std::vector<std::string> &nicknames =
 706         m_abstractContact->getNickNames();
 707
 708     if (nicknames.size() == 0) {
 709         return true;
 710     }
 711
 712     CTSvalue *nickname = NULL;
 713     bool properlyCreated = true;
 714     GSList *nicknameList = NULL;
 715     //mark existing items to delete them.
 716
 717     if (CTS_SUCCESS ==
 718         contacts_svc_struct_get_list(m_platformContact, CTS_CF_NICKNAME_LIST,
 719                                      &nicknameList)) {
 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,
 725                                         true);
 726         }
 727         nicknameList = nicknameListSave;
 728     }
 729     //add new items
 730     for (std::size_t i = 0; i < nicknames.size(); ++i) {
 731         nickname = contacts_svc_value_new(CTS_VALUE_NICKNAME);
 732         if (nickname) {
 733             if (CTS_SUCCESS ==
 734                 contacts_svc_value_set_str(nickname, CTS_NICKNAME_VAL_NAME_STR,
 735                                            nicknames[i].c_str())) {
 736                 nicknameList = g_slist_append(nicknameList, nickname);
 737             } else {
 738                 contacts_svc_value_free(nickname);
 739                 properlyCreated = false;
 740                 break;
 741             }
 742         } else {
 743             properlyCreated = false;
 744             break;
 745         }
 746     }
 747
 748     if (properlyCreated) {
 749         if (CTS_SUCCESS !=
 750             contacts_svc_struct_store_list(m_platformContact,
 751                                            CTS_CF_NICKNAME_LIST,
 752                                            nicknameList)) {
 753             properlyCreated = false;
 754         }
 755     }
 756
 757     return properlyCreated;
 758 }
 759
 760 bool ContactWrapper::convertToPlatformPhoneticnameObject()
 761 {
 762     LogDebug("entered");
 763     if (NULL == m_abstractContact) {
 764         LogError("you should create empty abstract contact object first");
 765         return false;
 766     }
 767
 768     if (NULL == m_platformContact) {
 769         LogError("you should provide platform contact object first");
 770         return false;
 771     }
 772
 773     CTSvalue *value = NULL;
 774     int structFieldType = 0;
 775
 776     structFieldType = getCustomTypeInContactsSvc(
 777             CONTACT_ATTRIBUTE_PHONETIC_NAME);
 778     if (structFieldType < CTS_SUCCESS) {
 779         LogError("Phonetic name struct type is not found!!");
 780         return false;
 781     }
 782
 783     /**
 784        *If phonetic name information is not existed, add phonetic name information
 785        *If phonetic name information is existed,update phonetic name information
 786      */
 787     if (CTS_SUCCESS !=
 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);
 792         if (!value) {
 793             return false;
 794         }
 795     }
 796     if (CTS_SUCCESS !=
 797         contacts_svc_value_set_str(value, CTS_EXTEND_VAL_DATA2_STR,
 798                                    m_abstractContact->getPhoneticName().c_str())
 799         ||
 800         CTS_SUCCESS !=
 801         contacts_svc_struct_store_value(m_platformContact,
 802                                         static_cast<cts_struct_field>(
 803                                             structFieldType), value)) {
 804         contacts_svc_value_free(value);
 805         return false;
 806     }
 807     contacts_svc_value_free(value);
 808
 809     LogDebug("RETURN TRUE!!!");
 810     return true;
 811 }
 812
 813 bool ContactWrapper::convertToPlatformGroupObject()
 814 {
 815     LogDebug("entered");
 816     if (NULL == m_abstractContact) {
 817         LogError("you should create empty abstract contact object first");
 818         return false;
 819     }
 820
 821     if (NULL == m_platformContact) {
 822         LogError("you should provide platform contact object first");
 823         return false;
 824     }
 825
 826     const std::vector<std::string> &groups =
 827         m_abstractContact->getGroups();
 828     if (groups.size() == 0) {
 829         return true;
 830     }
 831     CTSvalue *group = NULL;
 832     bool properlyCreated = true;
 833     GSList *groupList = NULL;
 834     //mark existing items to delete them.
 835     if (CTS_SUCCESS ==
 836         contacts_svc_struct_get_list(m_platformContact, CTS_CF_GROUPREL_LIST,
 837                                      &groupList)) {
 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,
 844                                         true);
 845         }
 846         groupList = groupListSave;
 847     }
 848     //add new items
 849     for (std::size_t i = 0; i < groups.size(); ++i) {
 850         group = contacts_svc_value_new(CTS_VALUE_GROUP_RELATION);
 851         if (group) {
 852             int groupId = -1;
 853             //groupId = AddressBook::getGroupId(groups[i]);
 854
 855             CTSiter *iter = NULL;
 856             if (CTS_SUCCESS ==
 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);
 860                     if (findgroup) {
 861                         const char *foundGroupName = contacts_svc_value_get_str(
 862                                 findgroup,
 863                                 CTS_LIST_GROUP_NAME_STR);
 864                         if (foundGroupName && groups[i] == foundGroupName) {
 865                             groupId = contacts_svc_value_get_int(
 866                                     findgroup,
 867                                     CTS_LIST_GROUP_ID_INT);
 868                         }
 869                     }
 870                 }
 871                 contacts_svc_iter_remove(iter);
 872             }
 873             LogDebug("group id " << groupId);
 874             if (groupId != -1) {
 875                 if (CTS_SUCCESS ==
 876                     contacts_svc_value_set_int(group, CTS_GROUPREL_VAL_ID_INT,
 877                                                groupId)) {
 878                     groupList = g_slist_append(groupList, group);
 879                 } else {
 880                     contacts_svc_value_free(group);
 881                     properlyCreated = false;
 882                     break;
 883                 }
 884             } else {
 885                 contacts_svc_value_free(group);
 886                 properlyCreated = false;
 887                 break;
 888             }
 889         } else {
 890             properlyCreated = false;
 891             break;
 892         }
 893     }
 894     if (properlyCreated) {
 895         LogDebug("storing group list");
 896         if (CTS_SUCCESS !=
 897             contacts_svc_struct_store_list(m_platformContact,
 898                                            CTS_CF_GROUPREL_LIST,
 899                                            groupList)) {
 900             properlyCreated = false;
 901         }
 902     }
 903     for (; groupList; groupList = g_slist_next(groupList)) {
 904         contacts_svc_value_free(static_cast<CTSvalue*>(groupList->data));
 905     }
 906     g_slist_free(groupList);
 907     return properlyCreated;
 908 }
 909
 910 bool ContactWrapper::convertToPlatformPhoneObject()
 911 {
 912     LogDebug("entered");
 913     if (NULL == m_abstractContact) {
 914         LogError("you should create empty abstract contact object first");
 915         return false;
 916     }
 917
 918     if (NULL == m_platformContact) {
 919         LogError("you should provide platform contact object first");
 920         return false;
 921     }
 922
 923     int type;
 924     const std::vector<ContactPhoneNumberPtr> &phoneNumbers =
 925         m_abstractContact->getPhoneNumbers();
 926     if (phoneNumbers.size() == 0) {
 927         return true;
 928     }
 929     bool properlyCreated = true;
 930     CTSvalue *number = NULL;
 931     GSList *numberList = NULL;
 932     //mark existing items to delete them.
 933     if (CTS_SUCCESS ==
 934         contacts_svc_struct_get_list(m_platformContact, CTS_CF_NUMBER_LIST,
 935                                      &numberList)) {
 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);
 941         }
 942         numberList = numberListSave;
 943     }
 944     //add new items
 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)
 949         {
 950             number = contacts_svc_value_new(CTS_VALUE_NUMBER);
 951             if (number) {
 952                 if(types.size() > 0)
 953                 {
 954                     switch (types[j]) {
 955                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_WORK:
 956                         type = CTS_NUM_TYPE_WORK;
 957                         break;
 958                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PREF:
 959                         type = CTS_NUM_TYPE_NONE;
 960                         break;
 961                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_HOME:
 962                         type = CTS_NUM_TYPE_HOME;
 963                         break;
 964                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_FAX:
 965                         type = CTS_NUM_TYPE_FAX;
 966                         break;
 967                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CELL:
 968                         type = CTS_NUM_TYPE_CELL;
 969                         break;
 970                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PAGER:
 971                         type = CTS_NUM_TYPE_PAGER;
 972                         break;
 973                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_CAR:
 974                         type = CTS_NUM_TYPE_CAR;
 975                         break;
 976                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_BBS:
 977                         type = CTS_NUM_TYPE_BBS;
 978                         break;
 979                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MODEM:
 980                         type = CTS_NUM_TYPE_MODEM;
 981                         break;
 982                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_ISDN:
 983                         type = CTS_NUM_TYPE_ISDN;
 984                         break;
 985                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VIDEO:
 986                         type = CTS_NUM_TYPE_VIDEO;
 987                         break;
 988                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_PCS:
 989                         type = CTS_NUM_TYPE_PCS;
 990                         break;
 991                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_VOICE:
 992                         type = CTS_NUM_TYPE_VOICE;
 993                         break;
 994                     case ContactPhoneNumber::CONTACT_PHONE_NUMBER_TYPE_MSG:
 995                         type = CTS_NUM_TYPE_MSG;
 996                         break;
 997                     default:
 998                         LogError("invalid phone type");
 999                         type = CTS_NUM_TYPE_NONE;
1000                         break;
1001                     }
1002                 }
1003                 else
1004                 {
1005                     type = CTS_NUM_TYPE_NONE;
1006                 }
1007                 if (CTS_SUCCESS ==
1008                     contacts_svc_value_set_str(number, CTS_NUM_VAL_NUMBER_STR,
1009                                                phoneNumbers[i]->getNumber().
1010                                                    c_str()) &&
1011                     CTS_SUCCESS ==
1012                     contacts_svc_value_set_bool(number,
1013                                                 CTS_NUM_VAL_DEFAULT_BOOL,
1014                                                 type == CTS_NUM_TYPE_NONE) &&
1015                     CTS_SUCCESS ==
1016                     contacts_svc_value_set_int(number, CTS_NUM_VAL_TYPE_INT,
1017                                                type)) {
1018                     numberList = g_slist_append(numberList, number);
1019                 } else {
1020                     contacts_svc_value_free(number);
1021                     properlyCreated = false;
1022                     break;
1023                 }
1024             } else {
1025                 properlyCreated = false;
1026                 break;
1027             }
1028         }
1029         if (!properlyCreated) {
1030             break;
1031         }
1032     }
1033     if (properlyCreated) {
1034         if (CTS_SUCCESS !=
1035             contacts_svc_struct_store_list(m_platformContact,
1036                                            CTS_CF_NUMBER_LIST,
1037                                            numberList)) {
1038             properlyCreated = false;
1039         }
1040     }
1041     for (; numberList; numberList = g_slist_next(numberList)) {
1042         contacts_svc_value_free(static_cast<CTSvalue*>(numberList->data));
1043     }
1044     g_slist_free(numberList);
1045     return properlyCreated;
1046 }
1047
1048 bool ContactWrapper::convertToPlatformEmailObject()
1049 {
1050     LogDebug("entered");
1051     if (NULL == m_abstractContact) {
1052         LogError("you should create empty abstract contact object first");
1053         return false;
1054     }
1055
1056     if (NULL == m_platformContact) {
1057         LogError("you should provide platform contact object first");
1058         return false;
1059     }
1060
1061     int type;
1062     const std::vector<ContactEmailPtr> &emails =
1063         m_abstractContact->getEmails();
1064     if (emails.size() == 0) {
1065         return true;
1066     }
1067     CTSvalue *email = NULL;
1068     bool properlyCreated = true;
1069     GSList *emailList = NULL;
1070     //mark existing items to delete them.
1071     if (CTS_SUCCESS ==
1072         contacts_svc_struct_get_list(m_platformContact, CTS_CF_EMAIL_LIST,
1073                                      &emailList)) {
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);
1079         }
1080         emailList = emailListSave;
1081     }
1082     //add new items
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)
1087             {
1088                 email = contacts_svc_value_new(CTS_VALUE_EMAIL);
1089                 if(email)
1090                 {
1091                     if(types.size() > 0)
1092                     {
1093                         switch (types[j]) {
1094                         case ContactEmail::CONTACT_EMAIL_TYPE_HOME:
1095                             type = CTS_EMAIL_TYPE_HOME;
1096                             break;
1097                         case ContactEmail::CONTACT_EMAIL_TYPE_WORK:
1098                             type = CTS_EMAIL_TYPE_WORK;
1099                             break;
1100                         case ContactEmail::CONTACT_EMAIL_TYPE_PREF:
1101                             type = CTS_EMAIL_TYPE_NONE;
1102                             break;
1103                         default:
1104                             LogError("invalid phone type");
1105                             type = CTS_EMAIL_TYPE_NONE;
1106                             break;
1107                         }
1108                     }
1109                     else
1110                     {
1111                         type = CTS_EMAIL_TYPE_NONE;
1112                     }
1113                     if (CTS_SUCCESS ==
1114                         contacts_svc_value_set_int(email, CTS_EMAIL_VAL_TYPE_INT,
1115                                                    type) &&
1116                         CTS_SUCCESS ==
1117                         contacts_svc_value_set_str(email, CTS_EMAIL_VAL_ADDR_STR,
1118                                                    emails[i]->getEmail().c_str()))
1119                     {
1120                         emailList = g_slist_append(emailList, email);
1121                     } else {
1122                         contacts_svc_value_free(email);
1123                         properlyCreated = false;
1124                         break;
1125                     }
1126                 }
1127                 else
1128                 {
1129                     properlyCreated = false;
1130                     break;
1131                 }
1132         }
1133
1134         if (!properlyCreated) {
1135             break;
1136         }
1137     }
1138     if (properlyCreated) {
1139         if (CTS_SUCCESS !=
1140             contacts_svc_struct_store_list(m_platformContact, CTS_CF_EMAIL_LIST,
1141                                            emailList)) {
1142             properlyCreated = false;
1143         }
1144     }
1145     for (; emailList; emailList = g_slist_next(emailList)) {
1146         contacts_svc_value_free(static_cast<CTSvalue*>(emailList->data));
1147     }
1148     g_slist_free(emailList);
1149     return properlyCreated;
1150 }
1151
1152 bool ContactWrapper::convertToPlatformAddressObject()
1153 {
1154     LogDebug("entered");
1155     if (NULL == m_abstractContact) {
1156         LogError("you should create empty abstract contact object first");
1157         return false;
1158     }
1159
1160     if (NULL == m_platformContact) {
1161         LogError("you should provide platform contact object first");
1162         return false;
1163     }
1164
1165     int type;
1166     const std::vector<ContactAddressPtr> &addresses =
1167         m_abstractContact->getAddresses();
1168     if (addresses.size() == 0) {
1169         return true;
1170     }
1171     CTSvalue *address = NULL;
1172     bool properlyCreated = true;
1173     GSList *addressList = NULL;
1174     //mark existing items to delete them.
1175     if (CTS_SUCCESS ==
1176         contacts_svc_struct_get_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST,
1177                                      &addressList)) {
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,
1184                                         true);
1185         }
1186         addressList = addressListSave;
1187     }
1188     //add new items
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);
1194             if (address) {
1195                 //TODO "no place to store: county, premises, additional information in platform struct"
1196                 switch (types[j]) {
1197                 case ContactAddress::CONTACT_ADDRESS_TYPE_PREF:
1198                     type = CTS_ADDR_TYPE_NONE;
1199                     break;
1200                 case ContactAddress::CONTACT_ADDRESS_TYPE_WORK:
1201                     type = CTS_ADDR_TYPE_WORK;
1202                     break;
1203                 case ContactAddress::CONTACT_ADDRESS_TYPE_HOME:
1204                     type = CTS_ADDR_TYPE_HOME;
1205                     break;
1206                 default:
1207                     LogError("invalid address type");
1208                     type = CTS_EMAIL_TYPE_NONE;
1209                     break;
1210                 }
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()) &&
1214                 if (CTS_SUCCESS ==
1215                     contacts_svc_value_set_int(address, CTS_POSTAL_VAL_TYPE_INT,
1216                                                type) &&
1217                     CTS_SUCCESS ==
1218                     contacts_svc_value_set_str(address,
1219                                                CTS_POSTAL_VAL_COUNTRY_STR,
1220                                                addresses[i]->getCountry().c_str())
1221                     &&
1222                     CTS_SUCCESS ==
1223                     contacts_svc_value_set_str(address,
1224                                                CTS_POSTAL_VAL_REGION_STR,
1225                                                addresses[i]->getRegion().c_str())
1226                     &&
1227                     CTS_SUCCESS ==
1228                     contacts_svc_value_set_str(address,
1229                                                CTS_POSTAL_VAL_LOCALITY_STR,
1230                                                addresses[i]->getCity().c_str())
1231                     &&
1232                     CTS_SUCCESS ==
1233                     contacts_svc_value_set_str(address,
1234                                                CTS_POSTAL_VAL_STREET_STR,
1235                                                addresses[i]->getStreet().c_str())
1236                     &&
1237                     CTS_SUCCESS ==
1238                     contacts_svc_value_set_str(address,
1239                                                CTS_POSTAL_VAL_POBOX_STR,
1240                                                addresses[i]->getStreetNumber().
1241                                                    c_str()) &&
1242                     CTS_SUCCESS ==
1243                     contacts_svc_value_set_str(address,
1244                                                CTS_POSTAL_VAL_POSTALCODE_STR,
1245                                                addresses[i]->getPostalCode().
1246                                                    c_str()) &&
1247                     CTS_SUCCESS ==
1248                     contacts_svc_value_set_str(address,
1249                                                CTS_POSTAL_VAL_EXTENDED_STR,
1250                                                addresses[i]->
1251                                                    getAdditionalInformation().
1252                                                    c_str())) {
1253                     addressList = g_slist_append(addressList, address);
1254                 } else {
1255                     contacts_svc_value_free(address);
1256                     properlyCreated = false;
1257                     break;
1258                 }
1259             } else {
1260                 properlyCreated = false;
1261                 break;
1262             }
1263         }
1264         if (!properlyCreated) {
1265             break;
1266         }
1267     }
1268     if (properlyCreated) {
1269         if (CTS_SUCCESS !=
1270             contacts_svc_struct_store_list(m_platformContact,
1271                                            CTS_CF_POSTAL_ADDR_LIST,
1272                                            addressList)) {
1273             properlyCreated = false;
1274         }
1275     }
1276     for (; addressList; addressList = g_slist_next(addressList)) {
1277         contacts_svc_value_free(static_cast<CTSvalue*>(addressList->data));
1278     }
1279     g_slist_free(addressList);
1280     return properlyCreated;
1281 }
1282
1283 bool ContactWrapper::convertToPlatformBaseData()
1284 {
1285     LogDebug("entered");
1286     if (NULL == m_abstractContact) {
1287         LogError("you should create empty abstract contact object first");
1288         return false;
1289     }
1290
1291     if (NULL == m_platformContact) {
1292         LogError("you should provide platform contact object first");
1293         return false;
1294     }
1295
1296     /**
1297        *If name information is not existed, add name information
1298      * If  name information is existed,update name information
1299      */
1300     CTSvalue *value = NULL;
1301
1302     if (CTS_SUCCESS !=
1303         contacts_svc_struct_get_value(m_platformContact, CTS_CF_NAME_VALUE,
1304                                       &value)) {
1305         CTSvalue *value = contacts_svc_value_new(CTS_VALUE_NAME);
1306         if (value) {
1307             if (CTS_SUCCESS !=
1308                 contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR,
1309                                            m_abstractContact->getFirstName().
1310                                                c_str()) ||
1311                 CTS_SUCCESS !=
1312                 contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR,
1313                                            m_abstractContact->getLastName().
1314                                                c_str()) ||
1315                 CTS_SUCCESS !=
1316                 contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR,
1317                                            m_abstractContact->getFullName().
1318                                                c_str()) ||
1319                 CTS_SUCCESS !=
1320                 contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR,
1321                                            m_abstractContact->getTitle().c_str())
1322                 ||
1323                 CTS_SUCCESS !=
1324                 contacts_svc_struct_store_value(m_platformContact,
1325                                                 CTS_CF_NAME_VALUE, value)) {
1326                 contacts_svc_value_free(value);
1327                 return false;
1328             }
1329             contacts_svc_value_free(value);
1330         } else {
1331             return false;
1332         }
1333     } else {
1334         if (CTS_SUCCESS !=
1335             contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR,
1336                                        m_abstractContact->getFirstName().c_str())
1337             ||
1338             CTS_SUCCESS !=
1339             contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR,
1340                                        m_abstractContact->getLastName().c_str())
1341             ||
1342             CTS_SUCCESS !=
1343             contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR,
1344                                        m_abstractContact->getFullName().c_str())
1345             ||
1346             CTS_SUCCESS !=
1347             contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR,
1348                                        m_abstractContact->getTitle().c_str()))
1349         {
1350             contacts_svc_value_free(value);
1351             return false;
1352         }
1353         contacts_svc_value_free(value);
1354     }
1355
1356     /**
1357        *If photo and ringtone uri information is not existed, add the information
1358      * If photo and ringtone uri is existed,update the information
1359      */
1360     CTSvalue *baseinfo = NULL;
1361     if (CTS_SUCCESS !=
1362         contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE,
1363                                       &baseinfo)) {
1364         baseinfo = contacts_svc_value_new(CTS_VALUE_CONTACT_BASE_INFO);
1365         if (baseinfo) {
1366             if (m_abstractContact->getPhotoIsSet()) {
1367                 if (CTS_SUCCESS !=
1368                     contacts_svc_value_set_str(baseinfo,
1369                                                CTS_BASE_VAL_IMG_PATH_STR,
1370                                                m_abstractContact->getPhotoUri()
1371                                                    .c_str())) {
1372                     contacts_svc_value_free(baseinfo);
1373                     return false;
1374                 }
1375             }
1376             if (CTS_SUCCESS !=
1377                 contacts_svc_value_set_str(baseinfo,
1378                                            CTS_BASE_VAL_RINGTONE_PATH_STR,
1379                                            m_abstractContact->getRingTonePath()
1380                                                .c_str()) ||
1381                 CTS_SUCCESS !=
1382                 contacts_svc_struct_store_value(m_platformContact,
1383                                                 CTS_CF_BASE_INFO_VALUE,
1384                                                 baseinfo)) {
1385                 contacts_svc_value_free(baseinfo);
1386                 return false;
1387             }
1388
1389             contacts_svc_value_free(baseinfo);
1390         } else {
1391             return false;
1392         }
1393     } else {
1394         const char * oldimgpath = NULL;
1395         oldimgpath = contacts_svc_value_get_str(baseinfo,
1396                                                 CTS_BASE_VAL_IMG_PATH_STR);
1397
1398         std::string stroldimgpath = "";
1399         if (NULL != oldimgpath) {
1400             stroldimgpath = static_cast<std::string>(oldimgpath);
1401         }
1402
1403         std::string strnewimgpath = m_abstractContact->getPhotoUri();
1404         if (stroldimgpath != strnewimgpath) {
1405             if (CTS_SUCCESS !=
1406                 contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR,
1407                                            strnewimgpath.c_str())) {
1408                 contacts_svc_value_free(value);
1409                 return false;
1410             }
1411         }
1412
1413         if (CTS_SUCCESS !=
1414             contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR,
1415                                        m_abstractContact->getRingTonePath().
1416                                            c_str())) {
1417             return false;
1418         }
1419         contacts_svc_value_free(value);
1420     }
1421
1422     //save company information
1423     CTSvalue *company = NULL;
1424     company = contacts_svc_value_new(CTS_VALUE_COMPANY);
1425     if (company) {
1426         if (CTS_SUCCESS !=
1427             contacts_svc_value_set_str(company, CTS_COMPANY_VAL_NAME_STR,
1428                                        m_abstractContact->getCompany().c_str())
1429             ||
1430             CTS_SUCCESS !=
1431             contacts_svc_struct_store_value(m_platformContact,
1432                                             CTS_CF_COMPANY_VALUE,
1433                                             company)) {
1434             contacts_svc_value_free(company);
1435             return false;
1436         }
1437         contacts_svc_value_free(value);
1438     } else {
1439         return false;
1440     }
1441
1442     return true;
1443 }
1444
1445 int ContactWrapper::getCustomTypeInContactsSvc(const std::string &typeName)
1446 const
1447 {
1448     int structFieldType = -1;
1449
1450     LogDebug("typeName : " << typeName);
1451     structFieldType = contacts_svc_find_custom_type(CTS_TYPE_CLASS_EXTEND_DATA,
1452                                                     const_cast<char*>(typeName.
1453                                                                           c_str()));
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");
1461         }
1462     } else if (CTS_SUCCESS > structFieldType) {
1463         LogDebug("contacts_svc_find_custom_type is fail");
1464     }
1465
1466     LogDebug("structFieldType : " << structFieldType);
1467     return structFieldType;
1468 }
1469
1470 void ContactWrapper::printPlatformObject()
1471 {
1472     LogDebug("entered");
1473 }
1474
1475 void ContactWrapper::printAbstractObject()
1476 {
1477     LogDebug("entered");
1478 }
1479 }
1480 }