src/standards/Tizen/NFC/JSNFCTagMifareUltra.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 "JSNFCTagMifareUltra.h"
  19 #include "NFCConverter.h"
  20 #include "ResponseDispatcher.h"
  21 #include "JSNFCTag.h"
  22 #include <dpl/log/log.h>
  23
  24 #include <CommonsJavaScript/Validator.h>
  25 #include <Commons/Exception.h>
  26 #include <CommonsJavaScript/PrivateObject.h>
  27 #include <CommonsJavaScript/JSUtils.h>
  28 #include <CommonsJavaScript/JSCallbackManager.h>
  29 #include <CommonsJavaScript/Utils.h>
  30 #include <Tizen/Common/JSTizenExceptionFactory.h>
  31 #include <Tizen/Common/JSTizenException.h>
  32 #include <Tizen/Common/SecurityExceptions.h>
  33 #include <API/NFC/NFCFactory.h>
  34 #include <API/NFC/EventTagMifareUltraAction.h>
  35
  36 #include "plugin_config.h"
  37
  38
  39 using namespace TizenApis::Api::NFC;
  40 using namespace TizenApis::Commons;
  41 using namespace WrtDeviceApis::Commons;
  42 using namespace WrtDeviceApis::CommonsJavaScript;
  43 using namespace DPL;
  44
  45 #define TIZEN10_NFCTTAGMIFAREULTRA_ATTRIBUTENAME "NFCTagMifareUltra"
  46
  47 namespace TizenApis {
  48 namespace Tizen1_0 {
  49
  50  JSClassDefinition JSNFCTagMifareUltra::m_classInfo =
  51 {
  52     0,
  53     kJSClassAttributeNone,
  54     TIZEN10_NFCTTAGMIFAREULTRA_ATTRIBUTENAME,
  55     JSNFCTag::getClassRef(),
  56     NULL,
  57     m_function,
  58     initialize,
  59     finalize,
  60     NULL, //hasProperty,
  61     NULL,
  62     NULL, //setProperty,
  63     NULL, //DeleteProperty,
  64     NULL, //GetPropertyNames,
  65     NULL, //CallAsFunction,
  66     NULL, //CallAsConstructor,
  67     hasInstance, //HasInstance,
  68     NULL  //ConvertToType
  69 };
  70
  71
  72 JSStaticFunction JSNFCTagMifareUltra::m_function[] = {
  73     {"readPage", JSNFCTagMifareUltra::readPage, kJSPropertyAttributeNone},
  74     {"writePage", JSNFCTagMifareUltra::writePage, kJSPropertyAttributeNone},
  75     { 0, 0, 0}
  76 };
  77
  78 JSClassRef JSNFCTagMifareUltra::m_jsClassRef = JSClassCreate(JSNFCTagMifareUltra::getClassInfo());
  79
  80 JSObjectRef JSNFCTagMifareUltra::createJSObject(JSContextRef context, void *tagHandle, void* privManager) {
  81         LogDebug("entered");
  82
  83         INFCTagMifareUltraPtr NFCTagMifareUltra = NFCFactory::getInstance().createNFCTagMifareUltraObject(tagHandle);
  84         NFCTagMifareUltra->setPrivateNFCManagerPtr(privManager);
  85
  86         NFCTagMifareUltraPrivObject *priv = new NFCTagMifareUltraPrivObject(context, NFCTagMifareUltra);
  87
  88         if (!priv) {
  89                 ThrowMsg(NullPointerException, "Can not new a NFCTagMifareUltra object");
  90         }
  91
  92         return JSObjectMake(context, getClassRef(), priv);
  93 }
  94
  95 void JSNFCTagMifareUltra::initialize(JSContextRef context, JSObjectRef object)
  96 {
  97 }
  98
  99 void JSNFCTagMifareUltra::finalize(JSObjectRef object)
 100 {
 101         LogDebug( "entered" );
 102         NFCTagMifareUltraPrivObject *priv = static_cast<NFCTagMifareUltraPrivObject*>( JSObjectGetPrivate( object ) ) ;
 103         JSObjectSetPrivate(object, NULL);
 104         LogDebug("Deleting timezone object");
 105         delete priv;
 106 }
 107
 108
 109 const JSClassRef JSNFCTagMifareUltra::getClassRef()
 110 {
 111         if (!m_jsClassRef) {
 112                 m_jsClassRef = JSClassCreate(&m_classInfo);
 113         }
 114         return m_jsClassRef;
 115 }
 116
 117 const JSClassDefinition* JSNFCTagMifareUltra::getClassInfo()
 118 {
 119         return &m_classInfo;
 120 }
 121
 122 bool JSNFCTagMifareUltra::hasInstance(JSContextRef context,
 123         JSObjectRef constructor,
 124         JSValueRef possibleInstance,
 125         JSValueRef* exception)
 126 {
 127     return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 128 }
 129
 130 JSValueRef JSNFCTagMifareUltra::readPage(JSContextRef context,
 131         JSObjectRef object,
 132         JSObjectRef thisObject,
 133         size_t argumentCount,
 134         const JSValueRef arguments[],
 135         JSValueRef* exception)
 136 {
 137         LogDebug("Entered ");
 138
 139         NFCTagMifareUltraPrivObject* privateObject = static_cast<NFCTagMifareUltraPrivObject*>(JSObjectGetPrivate(thisObject));
 140         if (NULL == privateObject) {
 141                 LogError("private object is null");
 142                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 143         }
 144
 145         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 146         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 147
 148         NFCConverter convert(context);
 149         Validator validator(context, exception);
 150
 151         if ((argumentCount < 2) || (argumentCount > 3)) {
 152                 LogError("JSNFCTagMifareUltra::readPage argumentCount error");
 153                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 154         }
 155
 156         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSValueIsNumber(context, arguments[0])) {
 157                 LogError("JSNFCTagMifareUltra::readPage pageIndex TypeMismatchException!");
 158                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 159         }
 160
 161         if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 162                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 163                 LogError("JSNFCTagMifareUltra::readPage NFCDataReadCB TypeMismatchException!");
 164                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 165         }
 166         if ((argumentCount > 2) && !JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2]))) {
 167                 /* 2nd argument must be Callback. */
 168                 LogError("JSNFCTagMifareUltra::readPage errorCallback TypeMismatchException!");
 169                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 170         }
 171
 172         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 173         if (validator.isCallback(arguments[1])) {
 174                 onSuccessForCbm = arguments[1];
 175         }
 176         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 177                 onErrorForCbm = arguments[2];
 178         }
 179
 180
 181         INFCTagMifareUltraPtr NFCTagMifareUltra(privateObject->getObject());
 182         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 183         Try {
 184                 EventTagMifareUltraReadPagePtr event(new EventTagMifareUltraReadPage(convert.toInt(arguments[0])));
 185                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 186                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 187                 NFCTagMifareUltra->readPage(event);
 188
 189                 return JSValueMakeNull(context);;
 190         } Catch (ConversionException) {
 191                 LogError("JSNFCManager::readPage : ConversionException");
 192                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 193         } Catch (InvalidArgumentException) {
 194                 LogError("JSNFCManager::readPage InvalidArgumentException");
 195                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 196         } Catch (PlatformException) {
 197                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 198                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 199                 return JSValueMakeNull(context);
 200         } Catch (WrtDeviceApis::Commons::Exception) {
 201                 LogError("Exception: " << _rethrown_exception.GetMessage());
 202                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 203                 return JSValueMakeNull(context);
 204         }
 205
 206         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 207         return JSValueMakeNull(context);
 208 }
 209
 210 JSValueRef JSNFCTagMifareUltra::writePage(JSContextRef context,
 211         JSObjectRef object,
 212         JSObjectRef thisObject,
 213         size_t argumentCount,
 214         const JSValueRef arguments[],
 215         JSValueRef* exception)
 216 {
 217         LogDebug("Entered ");
 218
 219         NFCTagMifareUltraPrivObject* privateObject = static_cast<NFCTagMifareUltraPrivObject*>(JSObjectGetPrivate(thisObject));
 220         if (NULL == privateObject) {
 221                 LogError("private object is null");
 222                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 223         }
 224
 225         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_TAG_FUNCS);
 226         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 227
 228         NFCConverter convert(context);
 229         Validator validator(context, exception);
 230
 231         if ((argumentCount < 2) || (argumentCount > 4)) {
 232                 LogError("JSNFCTagMifareUltra::writePage argumentCount error");
 233                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 234         }
 235
 236         if ((JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !JSValueIsNumber(context, arguments[0]))
 237                 || (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !JSIsArrayValue(context, arguments[1]))){
 238                 LogError("JSNFCTagMifareUltra::writePage pageIndex or page TypeMismatchException!");
 239                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 240         }
 241
 242         if ((argumentCount > 2) && !JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2]))) {
 243                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 244                 LogError("JSNFCTagMifareUltra::writePage successCallback TypeMismatchException!");
 245                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 246         }
 247         if ((argumentCount > 3) && !JSValueIsNull(context, arguments[3]) && (JSValueIsUndefined(context, arguments[3]) || !validator.isCallback(arguments[3]))) {
 248                 /* 2nd argument must be Callback. */
 249                 LogError("JSNFCTagMifareUltra::writePage errorCallbackTypeMismatchException!");
 250                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 251         }
 252
 253         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 254         if ((argumentCount > 2) && (validator.isCallback(arguments[2]))) {
 255                 onSuccessForCbm = arguments[2];
 256         }
 257         if ((argumentCount > 3) && (validator.isCallback(arguments[3]))) {
 258                 onErrorForCbm = arguments[3];
 259         }
 260
 261
 262         INFCTagMifareUltraPtr NFCTagMifareUltra(privateObject->getObject());
 263         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 264         Try {
 265                 EventTagMifareUltraWritePagePtr event(new EventTagMifareUltraWritePage(convert.toInt(arguments[0]), convert.toVectorOfUChars(arguments[1])));
 266                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 267                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 268                 NFCTagMifareUltra->writePage(event);
 269
 270                 return JSValueMakeNull(context);
 271         } Catch (ConversionException) {
 272                 LogError("JSNFCManager::writePage : ConversionException");
 273                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 274         } Catch (InvalidArgumentException) {
 275                 LogError("JSNFCManager::writePage InvalidArgumentException");
 276                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid Values");
 277         } Catch (PlatformException) {
 278                 LogError("PlatformException: " << _rethrown_exception.GetMessage());
 279                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 280                 return JSValueMakeNull(context);
 281         } Catch (WrtDeviceApis::Commons::Exception) {
 282                 LogError("Exception: " << _rethrown_exception.GetMessage());
 283                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 284                 return JSValueMakeNull(context);
 285         }
 286
 287         callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 288         return JSValueMakeNull(context);
 289 }
 290
 291 }
 292 }