src/standards/Tizen/NFC/JSNFCTag.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
  18 #include "JSNFCTag.h"
  19 #include "JSNdefMessage.h"
  20 #include "JSNFCManager.h"
  21 #include "NFCConverter.h"
  22 #include "ResponseDispatcher.h"
  23 #include <dpl/log/log.h>
  24
  25 #include <CommonsJavaScript/Validator.h>
  26 #include <Commons/Exception.h>
  27 #include <CommonsJavaScript/PrivateObject.h>
  28 #include <CommonsJavaScript/JSUtils.h>
  29 #include <CommonsJavaScript/JSCallbackManager.h>
  30 #include <CommonsJavaScript/Utils.h>
  31 #include <Tizen/Common/JSTizenExceptionFactory.h>
  32 #include <Tizen/Common/JSTizenException.h>
  33 #include <Tizen/Common/SecurityExceptions.h>
  34 #include <API/NFC/NFCFactory.h>
  35 #include <API/NFC/EventTagAction.h>
  36
  37 #include "plugin_config.h"
  38
  39
  40 using namespace TizenApis::Api::NFC;
  41 using namespace TizenApis::Commons;
  42 using namespace WrtDeviceApis::Commons;
  43 using namespace WrtDeviceApis::CommonsJavaScript;
  44 using namespace DPL;
  45
  46 #define TIZEN10_NFCTAG_ATTRIBUTENAME "NFCTag"
  47
  48 #define TIZEN10_NFCTAG_TYPE "type"
  49 #define TIZEN10_NFCTAG_ISSUPPORTEDNDEF "isSupportedNDEF"
  50 #define TIZEN10_NFCTAG_NDEFSIZE "ndefSize"
  51 #define TIZEN10_NFCTAG_PROPERTIES "properties"
  52 #define TIZEN10_NFCTAG_ISCONNECTED "isConnected"
  53
  54 namespace TizenApis {
  55 namespace Tizen1_0 {
  56
  57  JSClassDefinition JSNFCTag::m_classInfo =
  58 {
  59     0,
  60     kJSClassAttributeNone,
  61     TIZEN10_NFCTAG_ATTRIBUTENAME,
  62     0,
  63     m_property,
  64     m_function,
  65     initialize,
  66     finalize,
  67     NULL, //hasProperty,
  68     NULL,
  69     NULL, //setProperty,
  70     NULL, //DeleteProperty,
  71     NULL, //GetPropertyNames,
  72     NULL, //CallAsFunction,
  73     NULL, //CallAsConstructor,
  74     NULL, //HasInstance,
  75     NULL  //ConvertToType
  76 };
  77
  78 JSStaticValue JSNFCTag::m_property[] =
  79 {
  80     //NFCTagProperties
  81     { TIZEN10_NFCTAG_TYPE, getProperty,
  82             NULL, kJSPropertyAttributeReadOnly},
  83     { TIZEN10_NFCTAG_ISSUPPORTEDNDEF, getProperty,
  84             NULL, kJSPropertyAttributeReadOnly},
  85     { TIZEN10_NFCTAG_NDEFSIZE, getProperty,
  86             NULL, kJSPropertyAttributeReadOnly},
  87     { TIZEN10_NFCTAG_PROPERTIES, getProperty,
  88             NULL, kJSPropertyAttributeReadOnly},
  89     { TIZEN10_NFCTAG_ISCONNECTED, getProperty,
  90             NULL, kJSPropertyAttributeReadOnly},
  91     { 0, 0, 0, 0 }
  92 };
  93
  94 JSStaticFunction JSNFCTag::m_function[] = {
  95     {"readNDEF", JSNFCTag::readNDEF, kJSPropertyAttributeNone},
  96     {"writeNDEF", JSNFCTag::writeNDEF, kJSPropertyAttributeNone},
  97     {"transceive", JSNFCTag::transceive, kJSPropertyAttributeNone},
  98     {"formatNDEF", JSNFCTag::formatNDEF, kJSPropertyAttributeNone},
  99     { 0, 0, 0}
 100 };
 101
 102 JSClassRef JSNFCTag::m_jsClassRef = JSClassCreate(JSNFCTag::getClassInfo());
 103
 104 JSObjectRef JSNFCTag::createJSObject(JSContextRef context, void *tagHandle, void* privManager) {
 105         LogDebug("entered");
 106
 107         INFCTagPtr NFCTag = NFCFactory::getInstance().createNFCTagObject(tagHandle);
 108         NFCTag->setPrivateNFCManagerPtr(privManager);
 109
 110         NFCTagPrivObject *priv = new NFCTagPrivObject(context, NFCTag);
 111
 112         if (!priv) {
 113                 ThrowMsg(NullPointerException, "Can not new a NFCTag object");
 114         }
 115
 116         return JSObjectMake(context, getClassRef(), priv);
 117 }
 118
 119 void JSNFCTag::initialize(JSContextRef context, JSObjectRef object)
 120 {
 121 }
 122
 123 void JSNFCTag::finalize(JSObjectRef object)
 124 {
 125         LogDebug( "entered" );
 126         NFCTagPrivObject *priv = static_cast<NFCTagPrivObject*>( JSObjectGetPrivate( object ) ) ;
 127         JSObjectSetPrivate(object, NULL);
 128         LogDebug("Deleting timezone object");
 129         delete priv;
 130 }
 131
 132
 133 const JSClassRef JSNFCTag::getClassRef()
 134 {
 135         if (!m_jsClassRef) {
 136                 m_jsClassRef = JSClassCreate(&m_classInfo);
 137         }
 138         return m_jsClassRef;
 139 }
 140
 141 const JSClassDefinition* JSNFCTag::getClassInfo()
 142 {
 143         return &m_classInfo;
 144 }
 145
 146 JSValueRef JSNFCTag::getProperty(JSContextRef context, JSObjectRef object,
 147         JSStringRef propertyName, JSValueRef* exception)
 148 {
 149         LogDebug("Enter");
 150
 151         Try     {
 152                 NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(object));
 153                 if (!privateObject) {
 154                         LogError("Private object is not set.");
 155                         ThrowMsg(NullPointerException, "Private object not initialized");
 156                 }
 157
 158                 INFCTagPtr NFCTag(privateObject->getObject());
 159                 NFCConverter convert(context);
 160
 161                 LogDebug("propertyName : " << convert.toString(propertyName));
 162                 if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTAG_TYPE)) {
 163                         return convert.toJSValueRef(convert.toNfcTagTypeString(NFCTag->getTagType()));
 164                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTAG_ISSUPPORTEDNDEF)) {
 165                         return convert.toJSValueRef(NFCTag->isNDEFSupport());
 166                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTAG_NDEFSIZE)) {
 167                         return convert.toJSValueRefLong(NFCTag->getNdefSize());
 168                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTAG_PROPERTIES)) {
 169                         LogDebug("get Properties");
 170                         return convert.toJSValueRef(NFCTag->getProperties());
 171                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTAG_ISCONNECTED)) {
 172                         NFCManagerPrivObject* privateNFCManager = static_cast<NFCManagerPrivObject*>(NFCTag->getPrivateNFCManagerPtr());
 173                         if (!privateNFCManager) {
 174                                 LogError("NFC Manager Private object is not set.");
 175                                 ThrowMsg(NullPointerException, "Private object not initialized");
 176                         }
 177                         INFCManagerPtr NFCManager(privateNFCManager->getObject());
 178                         return convert.toJSValueRef(NFCManager->isValidHandle(NFCTag->getHandle()));
 179                 }
 180         } Catch (ConversionException) {
 181                 LogError("ConversionException: " << _rethrown_exception.GetMessage());
 182         } Catch (WrtDeviceApis::Commons::Exception) {
 183                 LogError("Exception: " << _rethrown_exception.GetMessage());
 184         }
 185         return JSValueMakeUndefined(context);
 186 }
 187
 188 JSValueRef JSNFCTag::readNDEF(JSContextRef context,
 189         JSObjectRef object,
 190         JSObjectRef thisObject,
 191         size_t argumentCount,
 192         const JSValueRef arguments[],
 193         JSValueRef* exception)
 194 {
 195         LogDebug("Entered ");
 196
 197         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 198         if (NULL == privateObject) {
 199                 LogError("private object is null");
 200                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 201         }
 202
 203         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 204         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 205
 206         Validator validator(context, exception);
 207
 208         if (argumentCount < 1) {
 209                 LogError("JSNFCTag::readNDEF TypeMismatchException");
 210                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 211         }
 212         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !validator.isCallback(arguments[0])) {
 213                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 214                 LogError("JSNFCTag::readNDEF TypeMismatchException!");
 215                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 216         }
 217         if ((argumentCount > 1) && !JSValueIsNull(context, arguments[1])) {
 218                 if (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 219                         /* 2nd argument must be Callback. */
 220                         LogError("JSNFCTag::readNDEF TypeMismatchException!");
 221                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 222                 }
 223         }
 224
 225         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 226         if (validator.isCallback(arguments[0])) {
 227                 onSuccessForCbm = arguments[0];
 228         }
 229         if (argumentCount > 1) {
 230                 if (validator.isCallback(arguments[1])) {
 231                         onErrorForCbm = arguments[1];
 232                 }
 233         }
 234
 235         INFCTagPtr NFCTag(privateObject->getObject());
 236         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 237         Try {
 238                 EventTagActionReadPtr event(new EventTagActionRead());
 239                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 240                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 241
 242                 NFCTag->readNdef(event);
 243
 244                 return JSValueMakeNull(context);
 245         } Catch (ConversionException) {
 246                 LogError("JSNFCManager::readNDEF : ConversionException");
 247                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 248         } Catch (InvalidArgumentException) {
 249                 LogError("JSNFCManager::readNDEF InvalidArgumentException");
 250                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 251         } Catch (WrtDeviceApis::Commons::Exception) {
 252                 LogError("Exception: " << _rethrown_exception.GetMessage());
 253                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 254         }
 255
 256         return JSValueMakeNull(context);
 257 }
 258
 259 JSValueRef JSNFCTag::writeNDEF(JSContextRef context,
 260         JSObjectRef object,
 261         JSObjectRef thisObject,
 262         size_t argumentCount,
 263         const JSValueRef arguments[],
 264         JSValueRef* exception)
 265 {
 266         LogDebug("Entered ");
 267
 268         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 269         if (NULL == privateObject) {
 270                 LogError("private object is null");
 271                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 272         }
 273
 274         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 275         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 276
 277         NFCConverter convert(context);
 278         Validator validator(context, exception);
 279
 280         if (argumentCount < 2 ) {
 281                 LogError("JSNFCTag::writeNdef TypeMismatchException");
 282                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 283         }
 284         if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 285                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 286                 LogError("JSNFCTag::writeNdef TypeMismatchException!");
 287                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 288         }
 289         if ((argumentCount > 2) && (!JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2])))) {
 290                 /* 2nd argument must be Callback. */
 291                 LogError("JSNFCTag::writeNdef TypeMismatchException!");
 292                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 293         }
 294
 295         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 296         if (validator.isCallback(arguments[1])) {
 297                 onSuccessForCbm = arguments[1];
 298         }
 299
 300         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 301                 onErrorForCbm = arguments[2];
 302         }
 303
 304         void *messageHandle = convert.getMessageHandle(arguments[0]);
 305
 306         INFCTagPtr NFCTag(privateObject->getObject());
 307         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 308         Try {
 309                 EventTagActionWritePtr event(new EventTagActionWrite());
 310                 event->writeNdef(messageHandle);
 311                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 312                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 313                 NFCTag->writeNdef(event);
 314
 315                 return JSValueMakeNull(context);
 316         } Catch (ConversionException) {
 317                 LogError("JSNFCManager::writeNDEF : ConversionException");
 318                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 319         } Catch (InvalidArgumentException) {
 320                 LogError("JSNFCManager::writeNDEF InvalidArgumentException");
 321                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 322         } Catch (WrtDeviceApis::Commons::Exception) {
 323                 LogError("Exception: " << _rethrown_exception.GetMessage());
 324                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 325         }
 326
 327         return JSValueMakeNull(context);
 328 }
 329
 330 JSValueRef JSNFCTag::transceive(JSContextRef context,
 331         JSObjectRef object,
 332         JSObjectRef thisObject,
 333         size_t argumentCount,
 334         const JSValueRef arguments[],
 335         JSValueRef* exception)
 336 {
 337         LogDebug("Entered ");
 338
 339         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 340         if (NULL == privateObject) {
 341                 LogError("private object is null");
 342                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 343         }
 344
 345         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 346         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 347
 348         NFCConverter convert(context);
 349         Validator validator(context, exception);
 350
 351         if (argumentCount < 2 ) {
 352                 LogError("JSNFCTag::transceive TypeMismatchException");
 353                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 354         }
 355
 356         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSIsArrayValue(context, arguments[0])) {
 357                 /* 2nd argument must be Callback. */
 358                 LogError("JSNFCTag::transceive TypeMismatchException!");
 359                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 360         }
 361
 362         if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 363                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 364                 LogError("JSNFCTag::transceive TypeMismatchException!");
 365                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 366         }
 367         if ((argumentCount > 2) && (!JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2])))) {
 368                 /* 2nd argument must be Callback. */
 369                 LogError("JSNFCTag::transceive TypeMismatchException!");
 370                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 371         }
 372
 373         std::vector<unsigned char> data = convert.toVectorOfUChars(arguments[0]);
 374
 375         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 376         if (validator.isCallback(arguments[1])) {
 377                 onSuccessForCbm = arguments[1];
 378         }
 379
 380         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 381                 onErrorForCbm = arguments[2];
 382         }
 383
 384         INFCTagPtr NFCTag(privateObject->getObject());
 385         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 386         Try {
 387                 EventTagActionTransceivePtr event(new EventTagActionTransceive());
 388                 event->transceive(data);
 389                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 390                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 391                 NFCTag->transceive(event);
 392
 393                 return JSValueMakeNull(context);
 394         } Catch (ConversionException) {
 395                 LogError("JSNFCManager::transceive : ConversionException");
 396                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 397         } Catch (InvalidArgumentException) {
 398                 LogError("JSNFCManager::transceive InvalidArgumentException");
 399                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 400         } Catch (WrtDeviceApis::Commons::Exception) {
 401                 LogError("Exception: " << _rethrown_exception.GetMessage());
 402                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 403         }
 404
 405         return JSValueMakeNull(context);
 406 }
 407
 408 JSValueRef JSNFCTag::formatNDEF(JSContextRef context,
 409         JSObjectRef object,
 410         JSObjectRef thisObject,
 411         size_t argumentCount,
 412         const JSValueRef arguments[],
 413         JSValueRef* exception)
 414 {
 415         LogDebug("Entered ");
 416
 417         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 418         if (NULL == privateObject) {
 419                 LogError("private object is null");
 420                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 421         }
 422
 423         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 424         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 425
 426         NFCConverter convert(context);
 427         Validator validator(context, exception);
 428
 429         if (argumentCount < 1) {
 430                 LogError("JSNFCTag::formatNDEF TypeMismatchException");
 431                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 432         }
 433         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !validator.isCallback(arguments[0])) {
 434                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 435                 LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 436                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 437         }
 438         if ((argumentCount > 1) && !JSValueIsNull(context, arguments[1]) && (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1]))) {
 439                 /* 2nd argument must be Callback. */
 440                 LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 441                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 442         }
 443
 444         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 445         if (validator.isCallback(arguments[0])) {
 446                 onSuccessForCbm = arguments[0];
 447         }
 448
 449         if ((argumentCount > 1) && (validator.isCallback(arguments[1]))) {
 450                 onErrorForCbm = arguments[1];
 451         }
 452
 453         std::vector<unsigned char> key;
 454         if ((argumentCount > 2) && !JSValueIsNull(context, arguments[2])){
 455                 if (JSValueIsUndefined(context, arguments[2]) || !JSIsArrayValue(context, arguments[2])) {
 456                         /* 2nd argument must be Callback. */
 457                         LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 458                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 459                 }
 460                 key = convert.toVectorOfUChars(arguments[2]);
 461         }
 462
 463         INFCTagPtr NFCTag(privateObject->getObject());
 464         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 465         Try {
 466                 EventTagActionFormatPtr event(new EventTagActionFormat());
 467                 event->format(key);
 468                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 469                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 470                 NFCTag->format(event);
 471
 472                 return JSValueMakeNull(context);
 473         } Catch (ConversionException) {
 474                 LogError("JSNFCManager::formatNDEF : ConversionException");
 475                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 476         } Catch (InvalidArgumentException) {
 477                 LogError("JSNFCManager::formatNDEF InvalidArgumentException");
 478                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 479         } Catch (WrtDeviceApis::Commons::Exception) {
 480                 LogError("Exception: " << _rethrown_exception.GetMessage());
 481                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 482         }
 483
 484         return JSValueMakeNull(context);
 485 }
 486
 487 }
 488 }