src/standards/Tizen/NFC/JSNFCTarget.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 "JSNFCTarget.h"
  19 #include "JSNFCManager.h"
  20 #include "NFCConverter.h"
  21 #include "ResponseDispatcher.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/EventTargetAction.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_NFCTARGET_ATTRIBUTENAME "NFCTarget"
  46
  47 #define TIZEN10_NFCTARGET_ISCONNECTED "isConnected"
  48
  49 namespace TizenApis {
  50 namespace Tizen1_0 {
  51
  52  JSClassDefinition JSNFCTarget::m_classInfo =
  53 {
  54     0,
  55     kJSClassAttributeNone,
  56     TIZEN10_NFCTARGET_ATTRIBUTENAME,
  57     0,
  58     m_property,
  59     m_function,
  60     initialize,
  61     finalize,
  62     NULL, //hasProperty,
  63     NULL,
  64     NULL, //setProperty,
  65     NULL, //DeleteProperty,
  66     NULL, //GetPropertyNames,
  67     NULL, //CallAsFunction,
  68     NULL, //CallAsConstructor,
  69     NULL, //HasInstance,
  70     NULL  //ConvertToType
  71 };
  72
  73 JSStaticValue JSNFCTarget::m_property[] =
  74 {
  75     //NFCTargetProperties
  76     { TIZEN10_NFCTARGET_ISCONNECTED, getProperty,
  77             NULL, kJSPropertyAttributeReadOnly},
  78     { 0, 0, 0, 0 }
  79 };
  80
  81 JSStaticFunction JSNFCTarget::m_function[] = {
  82     {"setReceiveNDEFListener", JSNFCTarget::setReceiveNDEFListener, kJSPropertyAttributeNone},
  83     {"unsetReceiveNDEFListener", JSNFCTarget::unsetReceiveNDEFListener, kJSPropertyAttributeNone},
  84     {"sendNDEF", JSNFCTarget::sendNDEF, kJSPropertyAttributeNone},
  85     { 0, 0, 0}
  86 };
  87
  88 JSClassRef JSNFCTarget::m_jsClassRef = JSClassCreate(JSNFCTarget::getClassInfo());
  89
  90 JSObjectRef JSNFCTarget::createJSObject(JSContextRef context, void *tagHandle, void* privManager) {
  91         LogDebug("entered");
  92
  93         INFCTargetPtr NFCTarget = NFCFactory::getInstance().createNFCTargetObject(tagHandle);
  94         NFCTarget->setPrivateNFCManagerPtr(privManager);
  95
  96         NFCTargetPrivObject *priv = new NFCTargetPrivObject(context, NFCTarget);
  97
  98         if (!priv) {
  99                 ThrowMsg(NullPointerException, "Can not new a NFCTarget object");
 100         }
 101
 102         return JSObjectMake(context, getClassRef(), priv);
 103 }
 104
 105 void JSNFCTarget::initialize(JSContextRef context, JSObjectRef object)
 106 {
 107 }
 108
 109 void JSNFCTarget::finalize(JSObjectRef object)
 110 {
 111         LogDebug( "entered" );
 112         NFCTargetPrivObject *priv = static_cast<NFCTargetPrivObject*>( JSObjectGetPrivate( object ) ) ;
 113         JSObjectSetPrivate(object, NULL);
 114         LogDebug("Deleting timezone object");
 115         delete priv;
 116 }
 117
 118
 119 const JSClassRef JSNFCTarget::getClassRef()
 120 {
 121         if (!m_jsClassRef) {
 122                 m_jsClassRef = JSClassCreate(&m_classInfo);
 123         }
 124         return m_jsClassRef;
 125 }
 126
 127 const JSClassDefinition* JSNFCTarget::getClassInfo()
 128 {
 129         return &m_classInfo;
 130 }
 131
 132 JSValueRef JSNFCTarget::getProperty(JSContextRef context, JSObjectRef object,
 133         JSStringRef propertyName, JSValueRef* exception)
 134 {
 135         LogDebug("Enter");
 136
 137         Try     {
 138                 NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(object));
 139                 if (!privateObject) {
 140                         LogError("Private object is not set.");
 141                         ThrowMsg(NullPointerException, "Private object not initialized");
 142                 }
 143
 144                 INFCTargetPtr NFCTarget(privateObject->getObject());
 145                 NFCConverter convert(context);
 146
 147                 if (JSStringIsEqualToUTF8CString(propertyName, TIZEN10_NFCTARGET_ISCONNECTED)) {
 148                         NFCManagerPrivObject* privateNFCManager = static_cast<NFCManagerPrivObject*>(NFCTarget->getPrivateNFCManagerPtr());
 149                         if (!privateNFCManager) {
 150                                 LogError("NFC Manager Private object is not set.");
 151                                 ThrowMsg(NullPointerException, "Private object not initialized");
 152                         }
 153                         INFCManagerPtr NFCManager(privateNFCManager->getObject());
 154                         return convert.toJSValueRef(NFCManager->isValidHandle(NFCTarget->getHandle()));
 155                 }
 156         } Catch (ConversionException) {
 157                 LogError("ConversionException: " << _rethrown_exception.GetMessage());
 158         } Catch (WrtDeviceApis::Commons::Exception) {
 159                 LogError("Exception: " << _rethrown_exception.GetMessage());
 160         }
 161         return JSValueMakeUndefined(context);
 162 }
 163
 164 JSValueRef JSNFCTarget::setReceiveNDEFListener(JSContextRef context,
 165         JSObjectRef object,
 166         JSObjectRef thisObject,
 167         size_t argumentCount,
 168         const JSValueRef arguments[],
 169         JSValueRef* exception)
 170 {
 171         LogDebug("Entered ");
 172
 173         NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
 174         if (NULL == privateObject) {
 175                 LogError("private object is null");
 176                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 177         }
 178
 179         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_P2P_FUNCS);
 180         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 181
 182         NFCConverter convert(context);
 183         Validator validator(context, exception);
 184
 185         if (argumentCount < 1) {
 186                 LogError("JSNFCTarget::setReceiveNDEFListener TypeMismatchException");
 187                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 188         }
 189         if (JSValueIsNull(context, arguments[0]) || JSValueIsUndefined(context, arguments[0]) || !validator.isCallback(arguments[0])) {
 190                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 191                 LogError("JSNFCTarget::setReceiveNDEFListener TypeMismatchException!");
 192                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 193         }
 194         if ((argumentCount > 1)  && !JSValueIsNull(context, arguments[1])){
 195                 if (JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 196                         /* 2nd argument must be Callback. */
 197                         LogError("JSNFCTarget::setReceiveNDEFListener TypeMismatchException!");
 198                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 199                 }
 200         }
 201
 202         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 203         if (validator.isCallback(arguments[0])) {
 204                 onSuccessForCbm = arguments[0];
 205         }
 206         if (argumentCount > 1) {
 207                 if (validator.isCallback(arguments[1])) {
 208                         onErrorForCbm = arguments[1];
 209                 }
 210         }
 211
 212         INFCTargetPtr NFCTarget(privateObject->getObject());
 213         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 214         Try {
 215
 216                 EventTargetActionReceiveEmitterPtr emitter(new EventTargetActionReceiveEmitter);
 217                 emitter->setListener(&NFCResponseDispatcher::getInstance());
 218                 emitter->setEventPrivateData(StaticPointerCast<EventTargetActionReceive::PrivateDataType>(callbackManager));
 219                 NFCTarget->setReceiveNDEFListener(emitter);
 220                 return JSValueMakeNull(context);
 221         } Catch (ConversionException) {
 222                 LogError("JSNFCManager::setReceiveNDEFListener : ConversionException");
 223                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 224         } Catch (InvalidArgumentException) {
 225                 LogError("JSNFCManager::setReceiveNDEFListener InvalidArgumentException");
 226                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 227         } Catch (WrtDeviceApis::Commons::Exception) {
 228                 LogError("Exception: " << _rethrown_exception.GetMessage());
 229                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 230         }
 231
 232         return JSValueMakeNull(context);
 233 }
 234
 235 JSValueRef JSNFCTarget::unsetReceiveNDEFListener(JSContextRef context,
 236         JSObjectRef object,
 237         JSObjectRef thisObject,
 238         size_t argumentCount,
 239         const JSValueRef arguments[],
 240         JSValueRef* exception)
 241 {
 242         LogDebug("Entered ");
 243         Try {
 244                 NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
 245                 if (NULL == privateObject) {
 246                         LogError("private object is null");
 247                         return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 248                 }
 249
 250                 AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_P2P_FUNCS);
 251                 TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 252
 253                 INFCTargetPtr NFCTarget(privateObject->getObject());
 254                 NFCTarget->unsetReceiveNDEFListener();
 255
 256                 return JSValueMakeNull(context);
 257         } Catch (PlatformException) {
 258                 LogError("Exception: " << _rethrown_exception.GetMessage());
 259                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 260         } Catch(NullPointerException) {
 261                 LogError("Exception: " << _rethrown_exception.GetMessage());
 262                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 263         } Catch (WrtDeviceApis::Commons::Exception) {
 264                 LogError("Exception: " << _rethrown_exception.GetMessage());
 265                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 266         }
 267
 268         return JSValueMakeNull(context);
 269 }
 270
 271 JSValueRef JSNFCTarget::sendNDEF(JSContextRef context,
 272         JSObjectRef object,
 273         JSObjectRef thisObject,
 274         size_t argumentCount,
 275         const JSValueRef arguments[],
 276         JSValueRef* exception)
 277 {
 278         LogDebug("Entered ");
 279
 280         NFCTargetPrivObject* privateObject = static_cast<NFCTargetPrivObject*>(JSObjectGetPrivate(thisObject));
 281         if (NULL == privateObject) {
 282                 LogError("private object is null");
 283                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown Error");
 284         }
 285
 286         AceSecurityStatus status = NFC_CHECK_ACCESS(privateObject->getContext(),NFC_FUNCTION_API_P2P_FUNCS);
 287         TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
 288
 289
 290         NFCConverter convert(context);
 291         Validator validator(context, exception);
 292
 293         if (argumentCount < 2 ) {
 294                 LogError("JSNFCTarget::sendNDEF TypeMismatchException");
 295                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 296         }
 297         if (JSValueIsNull(context, arguments[1]) || JSValueIsUndefined(context, arguments[1]) || !validator.isCallback(arguments[1])) {
 298                 /* 1st argument is mandatory. And 1st argument must be Callback. */
 299                 LogError("JSNFCTarget::sendNDEF TypeMismatchException!");
 300                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 301         }
 302         if ((argumentCount > 2 ) && !JSValueIsNull(context, arguments[2]) && (JSValueIsUndefined(context, arguments[2]) || !validator.isCallback(arguments[2]))) {
 303                 /* 2nd argument must be Callback. */
 304                 LogError("JSNFCTarget::sendNDEF TypeMismatchException!");
 305                 return JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type Mismatch");
 306         }
 307
 308         void *messageHandle = convert.getMessageHandle(arguments[0]);
 309
 310         JSValueRef onSuccessForCbm = NULL, onErrorForCbm = NULL;
 311         if (validator.isCallback(arguments[1])) {
 312                 onSuccessForCbm = arguments[1];
 313         }
 314
 315         if ((argumentCount > 2 ) && (validator.isCallback(arguments[2]))) {
 316                 onErrorForCbm = arguments[2];
 317         }
 318
 319         INFCTargetPtr NFCTarget(privateObject->getObject());
 320         JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
 321         Try {
 322                 EventTargetActionSendPtr event(new EventTargetActionSend(messageHandle));
 323                 event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
 324                 event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
 325                 NFCTarget->sendNDEF(event);
 326                 return JSValueMakeNull(context);
 327         } Catch (ConversionException) {
 328                 LogError("JSNFCManager::sendNDEF : ConversionException");
 329                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 330         } Catch (InvalidArgumentException) {
 331                 LogError("JSNFCManager::sendNDEF InvalidArgumentException");
 332                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::INVALID_VALUES_ERROR,"Invalid Parameter"));
 333         } Catch (WrtDeviceApis::Commons::Exception) {
 334                 LogError("Exception: " << _rethrown_exception.GetMessage());
 335                 callbackManager->callOnError(JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR,"Unknown Error"));
 336         }
 337
 338         return JSValueMakeNull(context);
 339 }
 340
 341 }
 342 }