src/Contact/JSContactName.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        JSContactName.cpp
  20  * @author      Kisub Song (kisubs.song@samsung.com)
  21  * @version     0.1
  22  * @brief       Implementation of the JSContactName class
  23  */
  24
  25 #include <dpl/shared_ptr.h>
  26 #include <CommonsJavaScript/Validator.h>
  27 #include <JSWebAPIErrorFactory.h>
  28 #include "ContactConverter.h"
  29 #include "JSContactName.h"
  30 #include <Logger.h>
  31 #include <Export.h>
  32
  33 #define CONTACT_CLASS_NAME                                              "ContactName"
  34 #define CONTACT_PROP_ATTR_PREFIX                                "prefix"
  35 #define CONTACT_PROP_ATTR_SUFFIX                                "suffix"
  36 #define CONTACT_PROP_ATTR_FIRST_NAME                    "firstName"
  37 #define CONTACT_PROP_ATTR_MIDDLE_NAME                   "middleName"
  38 #define CONTACT_PROP_ATTR_LAST_NAME                             "lastName"
  39 #define CONTACT_PROP_ATTR_NICKNAMES                             "nicknames"
  40 #define CONTACT_PROP_ATTR_PHONETIC_NAME             "phoneticName"
  41 #define CONTACT_PROP_ATTR_PHONETIC_FIRST_NAME   "phoneticFirstName"
  42 #define CONTACT_PROP_ATTR_PHONETIC_MIDDLE_NAME  "phoneticMiddleName"
  43 #define CONTACT_PROP_ATTR_PHONETIC_LAST_NAME    "phoneticLastName"
  44 #define CONTACT_PROP_ATTR_DISPLAY_NAME                  "displayName"
  45
  46 namespace DeviceAPI {
  47 namespace Contact {
  48
  49 using namespace DeviceAPI::Common;
  50 using namespace WrtDeviceApis::Commons;
  51 using namespace WrtDeviceApis::CommonsJavaScript;
  52
  53 JSClassDefinition JSContactName::m_classInfo =
  54 {
  55         0,
  56         kJSClassAttributeNone,
  57         CONTACT_CLASS_NAME,
  58         NULL,
  59         m_property,
  60         m_functions,
  61         Initialize,
  62         Finalize,
  63         NULL, //hasProperty,
  64         NULL, //GetProperty,
  65         NULL, //SetProperty,
  66         NULL, //DeleteProperty,
  67         NULL, //getPropertyNames,
  68         NULL, //CallAsFunction,
  69         constructor, //CallAsConstructor,
  70         hasInstance, //HasInstance,
  71         NULL, //ConvertToType,
  72 };
  73
  74 JSStaticValue JSContactName::m_property[] = {
  75         { CONTACT_PROP_ATTR_PREFIX, getPrefix, setPrefix, kJSPropertyAttributeNone },
  76         { CONTACT_PROP_ATTR_SUFFIX, getSuffix, setSuffix, kJSPropertyAttributeNone },
  77         { CONTACT_PROP_ATTR_FIRST_NAME, getFirstName, setFirstName, kJSPropertyAttributeNone },
  78         { CONTACT_PROP_ATTR_MIDDLE_NAME, getMiddleName, setMiddleName, kJSPropertyAttributeNone },
  79         { CONTACT_PROP_ATTR_LAST_NAME, getLastName, setLastName, kJSPropertyAttributeNone },
  80         { CONTACT_PROP_ATTR_NICKNAMES, getNicknames, setNicknames, kJSPropertyAttributeNone },
  81         { CONTACT_PROP_ATTR_PHONETIC_NAME, getPhoneticName, setPhoneticName, kJSPropertyAttributeNone },
  82         { CONTACT_PROP_ATTR_PHONETIC_FIRST_NAME, getPhoneticFirstName, setPhoneticFirstName, kJSPropertyAttributeNone },
  83         { CONTACT_PROP_ATTR_PHONETIC_MIDDLE_NAME, getPhoneticMiddleName, setPhoneticMiddleName, kJSPropertyAttributeNone },
  84         { CONTACT_PROP_ATTR_PHONETIC_LAST_NAME, getPhoneticLastName, setPhoneticLastName, kJSPropertyAttributeNone },
  85         { CONTACT_PROP_ATTR_DISPLAY_NAME, getDisplayName, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
  86         { 0, 0, 0, 0 }
  87 };
  88
  89 JSStaticFunction JSContactName::m_functions[] =
  90 {
  91         { 0, 0, 0 }
  92 };
  93
  94 JSClassRef JSContactName::m_classRef = JSClassCreate(&m_classInfo);
  95
  96 JSClassRef DLL_EXPORT JSContactName::getClassRef()
  97 {
  98         if (!m_classRef) {
  99                 m_classRef = JSClassCreate(&m_classInfo);
 100         }
 101         return m_classRef;
 102 }
 103
 104 bool JSContactName::isObjectOfClass(JSContextRef context, JSValueRef value)
 105 {
 106         return JSValueIsObjectOfClass(context, value, getClassRef());
 107 }
 108
 109 ContactNamePtr JSContactName::getContactName(JSContextRef context, JSValueRef value)
 110 {
 111         if (!isObjectOfClass(context, value)) {
 112                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 113         }
 114
 115         JSObjectRef object = JSValueToObject(context, value, NULL);
 116         if (!object) {
 117                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 118         }
 119
 120         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 121         if (!priv) {
 122                 Throw(WrtDeviceApis::Commons::NullPointerException);
 123         }
 124
 125         return priv->getObject();
 126 }
 127
 128 void JSContactName::Initialize(JSContextRef context, JSObjectRef object)
 129 {
 130         if (!JSObjectGetPrivate(object))
 131         {
 132                 ContactNamePtr name(new ContactName());
 133                 JSContactNamePriv *priv = new JSContactNamePriv(context, ContactNamePtr(name));
 134                 if (!JSObjectSetPrivate(object, priv)) {
 135                         delete priv;
 136                 }
 137         }
 138 }
 139
 140 void JSContactName::Finalize(JSObjectRef object)
 141 {
 142         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 143
 144         if (priv != NULL)
 145                 delete (priv);
 146 }
 147
 148 JSObjectRef JSContactName::createJSObject(JSContextRef context, ContactNamePtr contactName)
 149 {
 150         JSContactNamePriv *priv = new JSContactNamePriv(context, contactName);
 151         JSObjectRef jsObjectRef = JSObjectMake(context, getClassRef(), static_cast<void*>(priv));
 152         if (NULL == jsObjectRef)
 153         {
 154                 LoggerE("object creation error");
 155                 return NULL;
 156         }
 157         return jsObjectRef;
 158 }
 159
 160 ContactNamePtr JSContactName::getPrivData(JSObjectRef object)
 161 {
 162         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 163         if (!priv) {
 164                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 165         }
 166
 167         ContactNamePtr result = priv->getObject();
 168         if (!result) {
 169                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 170         }
 171
 172         return result;
 173 }
 174
 175 JSObjectRef JSContactName::constructor(JSContextRef context,
 176                 JSObjectRef constructor,
 177                 size_t argumentCount,
 178                 const JSValueRef arguments[],
 179                 JSValueRef* exception)
 180 {
 181         bool js1stParamIsObject = false;
 182
 183         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(constructor));
 184         if (!priv) {
 185                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 186         }
 187         JSContextRef gContext = priv->getContext();
 188
 189         BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 190         Try {
 191                 if (argumentCount >= 1)
 192                 {
 193                         if (JSValueIsObject(gContext, arguments[0]))
 194                                 js1stParamIsObject = true;
 195
 196                         if (!js1stParamIsObject &&
 197                                         !JSValueIsNull(gContext, arguments[0]) &&
 198                                         !JSValueIsUndefined(gContext, arguments[0]))
 199                                 ThrowMsg(InvalidArgumentException, "1st argument must be 'object'");
 200                 }
 201
 202         } Catch(Exception ) {
 203                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 204                 *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "1st argument must be 'object'");
 205                 return NULL;
 206         }
 207
 208         ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 209
 210         ContactNamePtr contactName(NULL);
 211         Try {
 212                 if(js1stParamIsObject)
 213                         contactName = converter->toContactNameFromInit(arguments[0]);
 214                 else
 215                         contactName = ContactNamePtr(new ContactName());
 216
 217         } Catch(Exception) {
 218                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 219                 *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 220                 return NULL;
 221         }
 222
 223         JSObjectRef jsobject;
 224
 225         Try {
 226                 jsobject = createJSObject(gContext, contactName);
 227         } Catch(Exception) {
 228                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 229                 *exception = JSWebAPIErrorFactory::makeErrorObject(context, JSWebAPIErrorFactory::UNKNOWN_ERROR, "Internal error");
 230                 return NULL;
 231         }
 232
 233         return jsobject;
 234 }
 235
 236 bool JSContactName::hasInstance(JSContextRef context,
 237                 JSObjectRef constructor,
 238                 JSValueRef possibleInstance,
 239                 JSValueRef* exception)
 240 {
 241         return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 242 }
 243
 244 JSValueRef JSContactName::getPrefix(JSContextRef context,
 245                 JSObjectRef object,
 246                 JSStringRef propertyName,
 247                 JSValueRef* exception)
 248 {
 249         Try
 250         {
 251                 ContactConverterFactory::ConverterType converter =
 252                                 ContactConverterFactory::getConverter(context);
 253                 ContactNamePtr contactName = getPrivData(object);
 254                 if(!contactName->getPrefixIsSet())
 255                         return JSValueMakeNull(context);
 256                 else
 257                         return converter->toJSValueRef(contactName->getPrefix());
 258         }
 259         Catch(WrtDeviceApis::Commons::Exception)
 260         {
 261                 LoggerW("trying to get incorrect value");
 262         }
 263
 264         return JSValueMakeUndefined(context);
 265 }
 266
 267 bool JSContactName::setPrefix(JSContextRef context,
 268                 JSObjectRef object,
 269                 JSStringRef propertyName,
 270                 JSValueRef value,
 271                 JSValueRef* exception)
 272 {
 273         Try
 274         {
 275                 ContactNamePtr contactName = getPrivData(object);
 276                 ContactConverterFactory::ConverterType converter =
 277                                 ContactConverterFactory::getConverter(context);
 278                 BasicValidator validator =
 279                                 BasicValidatorFactory::getValidator(context, exception);
 280                 if(validator->isNullOrUndefined(value))
 281                         contactName->unsetPrefix();
 282                 else
 283                         contactName->setPrefix(converter->toString(value));
 284         }
 285         Catch(WrtDeviceApis::Commons::Exception)
 286         {
 287                 LoggerW("trying to set incorrect value");
 288                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 289         }
 290         return true;
 291 }
 292
 293 JSValueRef JSContactName::getSuffix(JSContextRef context,
 294                 JSObjectRef object,
 295                 JSStringRef propertyName,
 296                 JSValueRef* exception)
 297 {
 298         Try
 299         {
 300                 ContactConverterFactory::ConverterType converter =
 301                                 ContactConverterFactory::getConverter(context);
 302                 ContactNamePtr contactName = getPrivData(object);
 303                 if(!contactName->getSuffixIsSet())
 304                         return JSValueMakeNull(context);
 305                 else
 306                         return converter->toJSValueRef(contactName->getSuffix());
 307         }
 308         Catch(WrtDeviceApis::Commons::Exception)
 309         {
 310                 LoggerW("trying to get incorrect value");
 311         }
 312
 313         return JSValueMakeUndefined(context);
 314 }
 315
 316 bool JSContactName::setSuffix(JSContextRef context,
 317                 JSObjectRef object,
 318                 JSStringRef propertyName,
 319                 JSValueRef value,
 320                 JSValueRef* exception)
 321 {
 322         Try
 323         {
 324                 ContactNamePtr contactName = getPrivData(object);
 325                 ContactConverterFactory::ConverterType converter =
 326                                 ContactConverterFactory::getConverter(context);
 327                 BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 328                 if(validator->isNullOrUndefined(value))
 329                         contactName->unsetSuffix();
 330                 else
 331                         contactName->setSuffix(converter->toString(value));
 332         }
 333         Catch(WrtDeviceApis::Commons::Exception)
 334         {
 335                 LoggerW("trying to set incorrect value");
 336                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 337         }
 338         return true;
 339 }
 340
 341 JSValueRef JSContactName::getFirstName(JSContextRef context,
 342                 JSObjectRef object,
 343                 JSStringRef propertyName,
 344                 JSValueRef* exception)
 345 {
 346         Try
 347         {
 348                 ContactConverterFactory::ConverterType converter =
 349                                 ContactConverterFactory::getConverter(context);
 350                 ContactNamePtr contactName = getPrivData(object);
 351                 if(!contactName->getFirstNameIsSet())
 352                         return JSValueMakeNull(context);
 353                 else
 354                         return converter->toJSValueRef(contactName->getFirstName());
 355         }
 356         Catch(WrtDeviceApis::Commons::Exception)
 357         {
 358                 LoggerW("trying to get incorrect value");
 359         }
 360
 361         return JSValueMakeUndefined(context);
 362 }
 363
 364 bool JSContactName::setFirstName(JSContextRef context,
 365                 JSObjectRef object,
 366                 JSStringRef propertyName,
 367                 JSValueRef value,
 368                 JSValueRef* exception)
 369 {
 370         Try
 371         {
 372                 ContactNamePtr contactName = getPrivData(object);
 373                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
 374                 BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 375                 if(validator->isNullOrUndefined(value))
 376                         contactName->unsetFirstName();
 377                 else
 378                         contactName->setFirstName(converter->toString(value));
 379         }
 380         Catch(WrtDeviceApis::Commons::Exception)
 381         {
 382                 LoggerW("trying to set incorrect value");
 383                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 384         }
 385
 386         return true;
 387 }
 388
 389 JSValueRef JSContactName::getMiddleName(JSContextRef context,
 390                 JSObjectRef object,
 391                 JSStringRef propertyName,
 392                 JSValueRef* exception)
 393 {
 394         Try
 395         {
 396                 ContactConverterFactory::ConverterType converter =
 397                                 ContactConverterFactory::getConverter(context);
 398                 ContactNamePtr contactName = getPrivData(object);
 399                 if(!contactName->getMiddleNameIsSet())
 400                         return JSValueMakeNull(context);
 401                 else
 402                         return converter->toJSValueRef(contactName->getMiddleName());
 403         }
 404         Catch(WrtDeviceApis::Commons::Exception)
 405         {
 406                 LoggerW("trying to get incorrect value");
 407         }
 408
 409         return JSValueMakeUndefined(context);
 410 }
 411
 412 bool JSContactName::setMiddleName(JSContextRef context,
 413                 JSObjectRef object,
 414                 JSStringRef propertyName,
 415                 JSValueRef value,
 416                 JSValueRef* exception)
 417 {
 418         Try
 419         {
 420                 ContactNamePtr contactName = getPrivData(object);
 421                 ContactConverterFactory::ConverterType converter =
 422                                 ContactConverterFactory::getConverter(context);
 423                 BasicValidator validator =
 424                                 BasicValidatorFactory::getValidator(context, exception);
 425                 if(validator->isNullOrUndefined(value))
 426                         contactName->unsetMiddleName();
 427                 else
 428                         contactName->setMiddleName(converter->toString(value));
 429         }
 430         Catch(WrtDeviceApis::Commons::Exception)
 431         {
 432                 LoggerW("trying to set incorrect value");
 433                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 434         }
 435
 436         return true;
 437 }
 438
 439 JSValueRef JSContactName::getLastName(JSContextRef context,
 440                 JSObjectRef object,
 441                 JSStringRef propertyName,
 442                 JSValueRef* exception)
 443 {
 444         Try
 445         {
 446                 ContactConverterFactory::ConverterType converter =
 447                                 ContactConverterFactory::getConverter(context);
 448                 ContactNamePtr contactName = getPrivData(object);
 449                 if(!contactName->getLastNameIsSet())
 450                         return JSValueMakeNull(context);
 451                 else
 452                         return converter->toJSValueRef(contactName->getLastName());
 453         }
 454         Catch(WrtDeviceApis::Commons::Exception)
 455         {
 456                 LoggerW("trying to get incorrect value");
 457         }
 458
 459         return JSValueMakeUndefined(context);
 460 }
 461
 462 bool JSContactName::setLastName(JSContextRef context,
 463                 JSObjectRef object,
 464                 JSStringRef propertyName,
 465                 JSValueRef value,
 466                 JSValueRef* exception)
 467 {
 468         Try
 469         {
 470                 ContactNamePtr contactName = getPrivData(object);
 471                 ContactConverterFactory::ConverterType converter =
 472                                 ContactConverterFactory::getConverter(context);
 473                 BasicValidator validator =
 474                                 BasicValidatorFactory::getValidator(context, exception);
 475                 if(validator->isNullOrUndefined(value))
 476                         contactName->unsetLastName();
 477                 else
 478                         contactName->setLastName(converter->toString(value));
 479         }
 480         Catch(WrtDeviceApis::Commons::Exception)
 481         {
 482                 LoggerW("trying to set incorrect value");
 483                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 484         }
 485
 486         return true;
 487 }
 488
 489 JSValueRef JSContactName::getNicknames(JSContextRef context,
 490                 JSObjectRef object,
 491                 JSStringRef propertyName,
 492                 JSValueRef* exception)
 493 {
 494         Try
 495         {
 496                 JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 497                 if (!priv) {
 498                         ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 499                 }
 500                 JSContextRef gContext = priv->getContext();
 501
 502                 ContactConverterFactory::ConverterType converter =      ContactConverterFactory::getConverter(gContext);
 503                 ContactNamePtr contactName = getPrivData(object);
 504
 505                 if(contactName->IsTypesSetJSArray()){
 506                         return contactName->getTypesJSObj();
 507                 }else{
 508                         JSValueRef tempJSValue = contactName->getTypesJSArray();
 509                         tempJSValue = converter->toJSValueRef(contactName->getNicknames());
 510
 511                         JSObjectRef convertedJSObject = contactName->getTypesJSObj();
 512                         convertedJSObject = JSValueToObject( gContext, tempJSValue, NULL );
 513                         contactName->setTypesJSArray(true, convertedJSObject);
 514
 515                         JSValueProtect(gContext, convertedJSObject);
 516                         contactName->setContext(gContext);
 517                         return tempJSValue;
 518                 }
 519         }
 520         Catch(WrtDeviceApis::Commons::Exception)
 521         {
 522                 LoggerW("trying to get incorrect value");
 523         }
 524
 525         return JSValueMakeUndefined(context);
 526 }
 527
 528 bool JSContactName::setNicknames(JSContextRef context,
 529                 JSObjectRef object,
 530                 JSStringRef propertyName,
 531                 JSValueRef value,
 532                 JSValueRef* exception)
 533 {
 534         Try
 535         {
 536                 ContactNamePtr contactName = getPrivData(object);
 537                 ContactConverterFactory::ConverterType converter =
 538                                 ContactConverterFactory::getConverter(context);
 539                 contactName->setNicknames(converter->toStringArray(value));
 540                 contactName->resetTypesJSObj();
 541         }
 542         Catch(WrtDeviceApis::Commons::Exception)
 543         {
 544                 LoggerW("trying to set incorrect value");
 545                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 546         }
 547
 548         return true;
 549 }
 550
 551 JSValueRef JSContactName::getPhoneticName(JSContextRef context,
 552                 JSObjectRef object,
 553                 JSStringRef propertyName,
 554                 JSValueRef* exception)
 555 {
 556         // NOTE: Deprecated field.
 557         return JSValueMakeNull(context);
 558 }
 559
 560 bool JSContactName::setPhoneticName(JSContextRef context,
 561                 JSObjectRef object,
 562                 JSStringRef propertyName,
 563                 JSValueRef value,
 564                 JSValueRef* exception)
 565 {
 566         // NOTE: Deprecated field.
 567         return true;
 568 }
 569
 570 JSValueRef JSContactName::getPhoneticFirstName(JSContextRef context,
 571                 JSObjectRef object,
 572                 JSStringRef propertyName,
 573                 JSValueRef* exception)
 574 {
 575         Try
 576         {
 577                 ContactConverterFactory::ConverterType converter =
 578                                 ContactConverterFactory::getConverter(context);
 579                 ContactNamePtr contactName = getPrivData(object);
 580                 if(!contactName->getPhoneticFirstNameIsSet())
 581                         return JSValueMakeNull(context);
 582                 else
 583                         return converter->toJSValueRef(contactName->getPhoneticFirstName());
 584         }
 585         Catch(WrtDeviceApis::Commons::Exception)
 586         {
 587                 LoggerW("trying to get incorrect value");
 588         }
 589
 590         return JSValueMakeUndefined(context);
 591 }
 592
 593 bool JSContactName::setPhoneticFirstName(JSContextRef context,
 594                 JSObjectRef object,
 595                 JSStringRef propertyName,
 596                 JSValueRef value,
 597                 JSValueRef* exception)
 598 {
 599         Try
 600         {
 601                 ContactNamePtr contactName = getPrivData(object);
 602                 ContactConverterFactory::ConverterType converter =
 603                                 ContactConverterFactory::getConverter(context);
 604                 BasicValidator validator =
 605                                 BasicValidatorFactory::getValidator(context, exception);
 606                 if(validator->isNullOrUndefined(value))
 607                         contactName->unsetPhoneticFirstName();
 608                 else
 609                         contactName->setPhoneticFirstName(converter->toString(value));
 610         }
 611         Catch(WrtDeviceApis::Commons::Exception)
 612         {
 613                 LoggerW("trying to set incorrect value");
 614                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 615         }
 616
 617         return true;
 618 }
 619 JSValueRef JSContactName::getPhoneticMiddleName(JSContextRef context,
 620                 JSObjectRef object,
 621                 JSStringRef propertyName,
 622                 JSValueRef* exception)
 623 {
 624         Try
 625         {
 626                 ContactConverterFactory::ConverterType converter =
 627                                 ContactConverterFactory::getConverter(context);
 628                 ContactNamePtr contactName = getPrivData(object);
 629
 630                 if(!contactName->getPhoneticMiddleNameIsSet())
 631                         return JSValueMakeNull(context);
 632                 else
 633                         return converter->toJSValueRef(contactName->getPhoneticMiddleName());
 634         }
 635         Catch(WrtDeviceApis::Commons::Exception)
 636         {
 637                 LoggerW("trying to get incorrect value");
 638         }
 639
 640         return JSValueMakeUndefined(context);
 641 }
 642
 643 bool JSContactName::setPhoneticMiddleName(JSContextRef context,
 644                 JSObjectRef object,
 645                 JSStringRef propertyName,
 646                 JSValueRef value,
 647                 JSValueRef* exception)
 648 {
 649         Try
 650         {
 651                 ContactNamePtr contactName = getPrivData(object);
 652                 ContactConverterFactory::ConverterType converter =
 653                                 ContactConverterFactory::getConverter(context);
 654                 BasicValidator validator =
 655                                 BasicValidatorFactory::getValidator(context, exception);
 656                 if(validator->isNullOrUndefined(value))
 657                         contactName->unsetPhoneticMiddleName();
 658                 else
 659                         contactName->setPhoneticMiddleName(converter->toString(value));
 660         }
 661         Catch(WrtDeviceApis::Commons::Exception)
 662         {
 663                 LoggerW("trying to set incorrect value");
 664                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 665         }
 666
 667         return true;
 668 }
 669
 670 JSValueRef JSContactName::getPhoneticLastName(JSContextRef context,
 671                 JSObjectRef object,
 672                 JSStringRef propertyName,
 673                 JSValueRef* exception)
 674 {
 675         Try
 676         {
 677                 ContactConverterFactory::ConverterType converter =
 678                                 ContactConverterFactory::getConverter(context);
 679                 ContactNamePtr contactName = getPrivData(object);
 680                 if(!contactName->getPhoneticLastNameIsSet())
 681                         return JSValueMakeNull(context);
 682                 else
 683                         return converter->toJSValueRef(contactName->getPhoneticLastName());
 684         }
 685         Catch(WrtDeviceApis::Commons::Exception)
 686         {
 687                 LoggerW("trying to get incorrect value");
 688         }
 689
 690         return JSValueMakeUndefined(context);
 691 }
 692
 693 bool JSContactName::setPhoneticLastName(JSContextRef context,
 694                 JSObjectRef object,
 695                 JSStringRef propertyName,
 696                 JSValueRef value,
 697                 JSValueRef* exception)
 698 {
 699         Try
 700         {
 701                 ContactNamePtr contactName = getPrivData(object);
 702                 ContactConverterFactory::ConverterType converter =
 703                                 ContactConverterFactory::getConverter(context);
 704                 BasicValidator validator =
 705                                 BasicValidatorFactory::getValidator(context, exception);
 706                 if(validator->isNullOrUndefined(value))
 707                         contactName->unsetPhoneticLastName();
 708                 else
 709                         contactName->setPhoneticLastName(converter->toString(value));
 710         }
 711         Catch(WrtDeviceApis::Commons::Exception)
 712         {
 713                 LoggerW("trying to set incorrect value");
 714                 JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, "Type mismatch");
 715         }
 716
 717         return true;
 718 }
 719
 720 JSValueRef JSContactName::getDisplayName(JSContextRef context,
 721                 JSObjectRef object,
 722                 JSStringRef propertyName,
 723                 JSValueRef* exception)
 724 {
 725         Try
 726         {
 727                 ContactConverterFactory::ConverterType converter =
 728                                 ContactConverterFactory::getConverter(context);
 729                 ContactNamePtr contactName = getPrivData(object);
 730                 if(!contactName->getDisplayNameIsSet())
 731                         return JSValueMakeNull(context);
 732                 else
 733                         return converter->toJSValueRef(contactName->getDisplayName());
 734         }
 735         Catch(WrtDeviceApis::Commons::Exception)
 736         {
 737                 LoggerW("trying to get incorrect value");
 738         }
 739
 740         return JSValueMakeUndefined(context);
 741 }
 742
 743 } // Contact
 744 } // DeviceAPI