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     hasInstance, //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 (NullPointerException) {
 181                 LogError("NullPointerException: " << _rethrown_exception.GetMessage());
 182         } Catch (ConversionException) {
 183                 LogError("ConversionException: " << _rethrown_exception.GetMessage());
 184         } Catch (WrtDeviceApis::Commons::Exception) {
 185                 LogError("Exception: " << _rethrown_exception.GetMessage());
 186         }
 187         return JSValueMakeUndefined(context);
 188 }
 189
 190 bool JSNFCTag::hasInstance(JSContextRef context,
 191         JSObjectRef constructor,
 192         JSValueRef possibleInstance,
 193         JSValueRef* exception)
 194 {
 195     return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 196 }
 197
 198 JSValueRef JSNFCTag::readNDEF(JSContextRef context,
 199         JSObjectRef object,
 200         JSObjectRef thisObject,
 201         size_t argumentCount,
 202         const JSValueRef arguments[],
 203         JSValueRef* exception)
 204 {
 205         LogDebug("Entered ");
 206
 207         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 208         if (NULL == privateObject) {
 209                 LogError("private object is null");
 210                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 211         }
 212
 213         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 214         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 215
 216         Validator validator(context, exception);
 217
 218         if ((argumentCount == 0) || (argumentCount > 2)) {
 219                 LogError("JSNFCTag::readNDEF TypeMismatchException");
 220                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 221         }
 222         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !validator.isCallback(arguments[0])) {
 223                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 224                 LogError("JSNFCTag::readNDEF TypeMismatchException!");
 225                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 226         }
 227         if ((argumentCount > 1) && !JSValueIsNull(context, arguments[1])) {
 228                 if (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 229                         /* 2nd argument must be Callback. */
 230                         LogError("JSNFCTag::readNDEF TypeMismatchException!");
 231                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 232                 }
 233         }
 234
 235         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 236         if (validator.isCallback(arguments[0])) {
 237                 onSuccessForCbm = arguments[0];
 238         }
 239         if (argumentCount > 1) {
 240                 if (validator.isCallback(arguments[1])) {
 241                         onErrorForCbm = arguments[1];
 242                 }
 243         }
 244
 245         INFCTagPtr NFCTag(privateObject->getObject());
 246         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 247         Try {
 248                 EventTagActionReadPtr event(new EventTagActionRead());
 249                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 250                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 251
 252                 NFCTag->readNdef(event);
 253
 254                 return JSValueMakeNull(context);
 255         } Catch (ConversionException) {
 256                 LogError("JSNFCManager::readNDEF : ConversionException");
 257                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 258         } Catch (InvalidArgumentException) {
 259                 LogError("JSNFCManager::readNDEF InvalidArgumentException");
 260                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 261         } Catch (PlatformException) {
 262                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 263                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 264                 return JSValueMakeNull(context);
 265         } Catch (WrtDeviceApis::Commons::Exception) {
 266                 LogError("Exception: " << _rethrown_exception.GetMessage());
 267                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 268                 return JSValueMakeNull(context);
 269         }
 270
 271         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 272         return JSValueMakeNull(context);
 273 }
 274
 275 JSValueRef JSNFCTag::writeNDEF(JSContextRef context,
 276         JSObjectRef object,
 277         JSObjectRef thisObject,
 278         size_t argumentCount,
 279         const JSValueRef arguments[],
 280         JSValueRef* exception)
 281 {
 282         LogDebug("Entered ");
 283
 284         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 285         if (NULL == privateObject) {
 286                 LogError("private object is null");
 287                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 288         }
 289
 290         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 291         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 292
 293         NFCConverter convert(context);
 294         Validator validator(context, exception);
 295
 296         if ((argumentCount < 1) || (argumentCount > 3)) {
 297                 LogError("JSNFCTag::writeNdef TypeMismatchException");
 298                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 299         }
 300         if ((argumentCount > 1) && (!JSValueIsNull(context, arguments[1]) && (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])))) {
 301                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 302                 LogError("JSNFCTag::writeNdef TypeMismatchException!");
 303                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 304         }
 305         if ((argumentCount > 2) && (!JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2])))) {
 306                 /* 2nd argument must be Callback. */
 307                 LogError("JSNFCTag::writeNdef TypeMismatchException!");
 308                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 309         }
 310
 311         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 312         if ((argumentCount > 1) && (validator.isCallback(arguments[1]))) {
 313                 onSuccessForCbm = arguments[1];
 314         }
 315
 316         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 317                 onErrorForCbm = arguments[2];
 318         }
 319
 320         void *messageHandle = convert.getMessageHandle(arguments[0]);
 321
 322         INFCTagPtr NFCTag(privateObject->getObject());
 323         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 324         Try {
 325                 EventTagActionWritePtr event(new EventTagActionWrite());
 326                 event->writeNdef(messageHandle);
 327                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 328                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 329                 NFCTag->writeNdef(event);
 330
 331                 return JSValueMakeNull(context);
 332         } Catch (ConversionException) {
 333                 LogError("JSNFCManager::writeNDEF : ConversionException");
 334                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 335         } Catch (InvalidArgumentException) {
 336                 LogError("JSNFCManager::writeNDEF InvalidArgumentException");
 337                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 338         } Catch (PlatformException) {
 339                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 340                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 341                 return JSValueMakeNull(context);
 342         } Catch (WrtDeviceApis::Commons::Exception) {
 343                 LogError("Exception: " << _rethrown_exception.GetMessage());
 344                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 345                 return JSValueMakeNull(context);
 346         }
 347
 348         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 349         return JSValueMakeNull(context);
 350 }
 351
 352 JSValueRef JSNFCTag::transceive(JSContextRef context,
 353         JSObjectRef object,
 354         JSObjectRef thisObject,
 355         size_t argumentCount,
 356         const JSValueRef arguments[],
 357         JSValueRef* exception)
 358 {
 359         LogDebug("Entered ");
 360
 361         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 362         if (NULL == privateObject) {
 363                 LogError("private object is null");
 364                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 365         }
 366
 367         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 368         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 369
 370         NFCConverter convert(context);
 371         Validator validator(context, exception);
 372
 373         if ((argumentCount < 2) || (argumentCount > 3)) {
 374                 LogError("JSNFCTag::transceive TypeMismatchException");
 375                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 376         }
 377
 378         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSIsArrayValue(context, arguments[0])) {
 379                 /* 2nd argument must be Callback. */
 380                 LogError("JSNFCTag::transceive TypeMismatchException!");
 381                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 382         }
 383
 384         if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 385                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 386                 LogError("JSNFCTag::transceive TypeMismatchException!");
 387                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 388         }
 389         if ((argumentCount > 2) && (!JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2])))) {
 390                 /* 2nd argument must be Callback. */
 391                 LogError("JSNFCTag::transceive TypeMismatchException!");
 392                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 393         }
 394
 395         std::vector<unsigned char> data = convert.toVectorOfUChars(arguments[0]);
 396
 397         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 398         if (validator.isCallback(arguments[1])) {
 399                 onSuccessForCbm = arguments[1];
 400         }
 401
 402         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 403                 onErrorForCbm = arguments[2];
 404         }
 405
 406         INFCTagPtr NFCTag(privateObject->getObject());
 407         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 408         Try {
 409                 EventTagActionTransceivePtr event(new EventTagActionTransceive());
 410                 event->transceive(data);
 411                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 412                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 413                 NFCTag->transceive(event);
 414
 415                 return JSValueMakeNull(context);
 416         } Catch (ConversionException) {
 417                 LogError("JSNFCManager::transceive : ConversionException");
 418                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 419         } Catch (InvalidArgumentException) {
 420                 LogError("JSNFCManager::transceive InvalidArgumentException");
 421                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 422         } Catch (PlatformException) {
 423                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 424                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 425                 return JSValueMakeNull(context);
 426         } Catch (WrtDeviceApis::Commons::Exception) {
 427                 LogError("Exception: " << _rethrown_exception.GetMessage());
 428                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 429                 return JSValueMakeNull(context);
 430         }
 431
 432         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 433         return JSValueMakeNull(context);
 434 }
 435
 436 JSValueRef JSNFCTag::formatNDEF(JSContextRef context,
 437         JSObjectRef object,
 438         JSObjectRef thisObject,
 439         size_t argumentCount,
 440         const JSValueRef arguments[],
 441         JSValueRef* exception)
 442 {
 443         LogDebug("Entered ");
 444
 445         NFCTagPrivObject* privateObject = static_cast<NFCTagPrivObject*>(JSObjectGetPrivate(thisObject));
 446         if (NULL == privateObject) {
 447                 LogError("private object is null");
 448                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 449         }
 450
 451         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 452         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 453
 454         NFCConverter convert(context);
 455         Validator validator(context, exception);
 456
 457         if (argumentCount > 3) {
 458                 LogError("JSNFCTag::formatNDEF TypeMismatchException");
 459                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 460         }
 461         if ((argumentCount > 0) && !JSValueIsNull(context, arguments[0]) && (JSValueIsUndefined(context, arguments[0]) || !validator.isCallback(arguments[0]))) {
 462                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 463                 LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 464                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 465         }
 466         if ((argumentCount > 1) && !JSValueIsNull(context, arguments[1]) && (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1]))) {
 467                 /* 2nd argument must be Callback. */
 468                 LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 469                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 470         }
 471
 472         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 473         if ((argumentCount > 0) && (validator.isCallback(arguments[0]))) {
 474                 onSuccessForCbm = arguments[0];
 475         }
 476
 477         if ((argumentCount > 1) && (validator.isCallback(arguments[1]))) {
 478                 onErrorForCbm = arguments[1];
 479         }
 480
 481         std::vector<unsigned char> key;
 482         if ((argumentCount > 2) && !JSValueIsNull(context, arguments[2])){
 483                 if (JSValueIsUndefined(context, arguments[2]) || !JSIsArrayValue(context, arguments[2])) {
 484                         /* 2nd argument must be Callback. */
 485                         LogError("JSNFCTag::formatNDEF TypeMismatchException!");
 486                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 487                 }
 488                 key = convert.toVectorOfUChars(arguments[2]);
 489         }
 490
 491         INFCTagPtr NFCTag(privateObject->getObject());
 492         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 493         Try {
 494                 EventTagActionFormatPtr event(new EventTagActionFormat());
 495                 event->format(key);
 496                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 497                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 498                 NFCTag->format(event);
 499
 500                 return JSValueMakeNull(context);
 501         } Catch (ConversionException) {
 502                 LogError("JSNFCManager::formatNDEF : ConversionException");
 503                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 504         } Catch (InvalidArgumentException) {
 505                 LogError("JSNFCManager::formatNDEF InvalidArgumentException");
 506                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 507         } Catch (PlatformException) {
 508                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 509                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 510                 return JSValueMakeNull(context);
 511         } Catch (WrtDeviceApis::Commons::Exception) {
 512                 LogError("Exception: " << _rethrown_exception.GetMessage());
 513                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 514                 return JSValueMakeNull(context);
 515         }
 516
 517         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 518         return JSValueMakeNull(context);
 519 }
 520
 521 }
 522 }