src/standards/Tizen/NFC/NFCConverter.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
  19 #include <dpl/log/log.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/ScopedJSStringRef.h>
  22 #include <CommonsJavaScript/JSUtils.h>
  23 #include "NFCConverter.h"
  24 #include "JSNdefRecord.h"
  25 #include "JSNdefMessage.h"
  26
  27 using namespace std;
  28 using namespace TizenApis::Api::NFC;
  29 using namespace WrtDeviceApis::CommonsJavaScript;
  30 using namespace WrtDeviceApis;
  31
  32
  33 #define NFC_FILTER_ATTRIBUTE_TAG_TYPES "tagTypes"
  34
  35 #define NFC_CHANGED_CALLBACK_ONATTATCH "onAttach"
  36 #define NFC_CHANGED_CALLBACK_ONDETACH "onDetach"
  37
  38 namespace TizenApis {
  39 namespace Tizen1_0 {
  40
  41 vector<std::string> NFCConverter::m_allowedTagFilterProperties;
  42
  43 NFCConverter::NFCConverter(JSContextRef context) : Converter(context)
  44 {
  45     LogDebug("entered");
  46     static bool init = initializeAllowedProperties();
  47     (void) init;
  48 }
  49
  50 NFCConverter::~NFCConverter()
  51 {
  52     LogDebug("entered");
  53 }
  54
  55 TagFilterPtr NFCConverter::toNFCTagFilter(JSValueRef jsValue)
  56 {
  57     LogDebug("entered");
  58     if (JSValueIsNull(m_context, jsValue) ||
  59         JSValueIsUndefined(m_context, jsValue)) {
  60         return TagFilterPtr(); //empty filter
  61     }
  62     TagFilterPtr filter(new TagFilter());
  63
  64     Validator validator(m_context);
  65
  66     if (!JSValueIsUndefined(m_context, jsValue)) {
  67         vector<std::string> filter_values(toVectorOfStrings(jsValue));
  68
  69         LogDebug("NFCConverter, start setting filter values, tag_types.size() : " << filter_values.size());
  70           for (unsigned int i=0; i<filter_values.size(); i++) {
  71                 nfcTagType filterValue = toNfcTagType(filter_values.at(i));
  72
  73                 filter->addTagTypeValue(filterValue);
  74                   LogDebug("NFCConverter,  tag_types.at(i): " << filter_values.at(i));
  75           }
  76     }
  77     LogDebug("NFCConverter,  filter size == " << filter->getFilterSize());
  78
  79     return filter;
  80 }
  81
  82
  83 nfcTagType NFCConverter::toNfcTagType(std::string typeString) {
  84         if (typeString == "ISO14443_A")
  85                 return NFC_TAGTYPE_ISO14443_A_PICC;
  86         else if (typeString == "ISO14443_4A")
  87                 return NFC_TAGTYPE_ISO14443_4A_PICC;
  88         else if (typeString == "ISO14443_3A")
  89                 return NFC_TAGTYPE_ISO14443_3A_PICC;
  90         else if (typeString == "MIFARE_MINI")
  91                 return NFC_TAGTYPE_MIFARE_MINI_PICC;
  92         else if (typeString == "MIFARE_1K")
  93                 return NFC_TAGTYPE_MIFARE_1K_PICC;
  94         else if (typeString == "MIFARE_4K")
  95                 return NFC_TAGTYPE_MIFARE_4K_PICC;
  96         else if (typeString == "MIFARE_ULTRA")
  97                 return NFC_TAGTYPE_MIFARE_ULTRA_PICC;
  98         else if (typeString == "MIFARE_DESFIRE")
  99                 return NFC_TAGTYPE_MIFARE_DESFIRE_PICC;
 100         else if (typeString == "ISO14443_B")
 101                 return NFC_TAGTYPE_ISO14443_B_PICC;
 102         else if (typeString == "ISO14443_4B")
 103                 return NFC_TAGTYPE_ISO14443_4B_PICC;
 104         else if (typeString == "ISO14443_BPRIME")
 105                 return NFC_TAGTYPE_ISO14443_BPRIME_PICC;
 106         else if (typeString == "FELICA")
 107                 return NFC_TAGTYPE_FELICA_PICC;
 108         else if (typeString == "JEWEL")
 109                 return NFC_TAGTYPE_JEWEL_PICC;
 110         else if (typeString == "ISO15693")
 111                 return NFC_TAGTYPE_ISO15693_PICC;
 112         else
 113                 ThrowMsg(Commons::InvalidArgumentException, "No Match Tag Type");
 114 }
 115
 116 std::string NFCConverter::toNfcTagTypeString(nfcTagType type) {
 117         switch (type) {
 118                 case NFC_TAGTYPE_GENERIC_PICC:
 119                         return "GENERIC_TARGET";
 120                         break;
 121                 case NFC_TAGTYPE_ISO14443_A_PICC:
 122                         return "ISO14443_A";
 123                         break;
 124                 case NFC_TAGTYPE_ISO14443_4A_PICC:
 125                         return "ISO14443_4A";
 126                         break;
 127                 case NFC_TAGTYPE_ISO14443_3A_PICC:
 128                         return "ISO14443_3A";
 129                         break;
 130                 case NFC_TAGTYPE_MIFARE_MINI_PICC:
 131                         return "MIFARE_MINI";
 132                         break;
 133                 case NFC_TAGTYPE_MIFARE_1K_PICC:
 134                         return "MIFARE_1K";
 135                         break;
 136                 case NFC_TAGTYPE_MIFARE_4K_PICC:
 137                         return "MIFARE_4K";
 138                         break;
 139                 case NFC_TAGTYPE_MIFARE_ULTRA_PICC:
 140                         return "MIFARE_ULTRA";
 141                         break;
 142                 case NFC_TAGTYPE_MIFARE_DESFIRE_PICC:
 143                         return "MIFARE_DESFIRE";
 144                         break;
 145                 case NFC_TAGTYPE_ISO14443_B_PICC:
 146                         return "ISO14443_B";
 147                         break;
 148                 case NFC_TAGTYPE_ISO14443_4B_PICC:
 149                         return "ISO14443_4B";
 150                         break;
 151                 case NFC_TAGTYPE_ISO14443_BPRIME_PICC:
 152                         return "ISO14443_BPRIME";
 153                         break;
 154                 case NFC_TAGTYPE_FELICA_PICC:
 155                         return "FELICA";
 156                         break;
 157                 case NFC_TAGTYPE_JEWEL_PICC:
 158                         return "JEWEL";
 159                         break;
 160                 case NFC_TAGTYPE_ISO15693_PICC:
 161                         return "ISO15693";
 162                         break;
 163                 case NFC_TAGTYPE_UNKNOWN_TARGET:
 164                 default:
 165                         return "UNKNOWN_TARGET";
 166                         break;
 167         }
 168 }
 169
 170 nfcTextEncodeUTF NFCConverter::toNfcTextEncodeUTF(std::string encodeString) {
 171         if (encodeString == "UTF-8")
 172                 return NFC_TEXT_ENCODE_UTF_8;
 173         else if (encodeString == "UTF-16")
 174                 return NFC_TEXT_ENCODE_UTF_16;
 175         else
 176                 Throw(ConversionException);
 177 }
 178
 179 std::string NFCConverter::toNfcTextEncodeUTFString(nfcTextEncodeUTF encode) {
 180         switch(encode) {
 181                 case NFC_TEXT_ENCODE_UTF_8:
 182                         return "UTF-8";
 183                         break;
 184                 case NFC_TEXT_ENCODE_UTF_16:
 185                         return "UTF-16";
 186                         break;
 187                 default:
 188                         Throw(ConversionException);
 189         }
 190 }
 191 bool NFCConverter::initializeAllowedProperties()
 192 {
 193     LogDebug("entered");
 194     //NFC Filter properties
 195     m_allowedTagFilterProperties.push_back(NFC_FILTER_ATTRIBUTE_TAG_TYPES);
 196      return true;
 197 }
 198
 199 JSValueRef NFCConverter::toJSValueRef(const std::vector<unsigned char>& arg) {
 200     JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
 201
 202     if (NULL == jsResult) {
 203         ThrowMsg(Commons::NullPointerException, "Could not create js array object");
 204     }
 205
 206     for (std::size_t i = 0; i < arg.size(); ++i) {
 207         JSValueRef tmpVal = JSValueMakeNumber(m_context, arg[i]);
 208         if (!JSSetArrayElement(m_context, jsResult, i, tmpVal)) {
 209             ThrowMsg(Commons::UnknownException, "Could not insert value into js array");
 210         }
 211     }
 212
 213     return jsResult;
 214 }
 215
 216 JSValueRef NFCConverter::toJSValueRef(NdefRecordProperties props) {
 217         JSObjectRef propertyRef = JSObjectMake(m_context, NULL, NULL);
 218
 219         ScopedJSStringRef jsTNFString(JSStringCreateWithUTF8CString("tnf"));
 220         ScopedJSStringRef jsTypeString(JSStringCreateWithUTF8CString("typeName"));
 221         ScopedJSStringRef jsIdString(JSStringCreateWithUTF8CString("id"));
 222
 223         JSObjectSetProperty(m_context, propertyRef, jsTNFString.get(), toJSValueRef(static_cast<int>(props.tnf)), kJSPropertyAttributeNone, NULL);
 224         JSObjectSetProperty(m_context, propertyRef, jsTypeString.get(), toJSValueRef(props.typeName), kJSPropertyAttributeNone, NULL);
 225         JSObjectSetProperty(m_context, propertyRef, jsIdString.get(), toJSValueRef(props.id), kJSPropertyAttributeNone, NULL);
 226
 227         return propertyRef;
 228 }
 229
 230 JSValueRef NFCConverter::toJSValueRef(std::vector<NFCTagProperties> props) {
 231         JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
 232         if (NULL == jsResult) {
 233                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException,
 234                          "Could not create js array object");
 235         }
 236
 237         for (std::size_t i = 0; i < props.size(); ++i) {
 238                 JSValueRef tmpVal = toJSValueRef(props[i].value);
 239                 if (!JSSetArrayElementInArrayList(m_context, jsResult, props[i].key.c_str(), tmpVal)) {
 240                         ThrowMsg(WrtDeviceApis::Commons::UnknownException,
 241                                  "Could not insert value into js array");
 242                 }
 243         }
 244         return jsResult;
 245 }
 246
 247 NdefRecordProperties NFCConverter::toNdefRecordProperties(JSValueRef value, JSValueRef* exception) {
 248         if (JSValueIsNull(m_context, value) || JSValueIsUndefined(m_context, value)) {
 249                 ThrowMsg(Commons::InvalidArgumentException,
 250                          "Message is JS null or JS undefined.");
 251         }
 252         JSObjectRef obj = toJSObjectRef(value);
 253
 254         if (!obj) {
 255                 LogError("Object is null");
 256                 ThrowMsg(Commons::NullPointerException, "Private object not initialized");
 257         }
 258
 259         NdefRecordProperties props;
 260         JSValueRef tnf_JSProperty = JSUtils::getJSProperty(m_context, value, "tnf", exception);
 261         JSValueRef type_JSProperty = JSUtils::getJSProperty(m_context, value, "typeName", exception);
 262         JSValueRef id_JSProperty = JSUtils::getJSProperty(m_context, value, "id", exception);
 263
 264         if (tnf_JSProperty != NULL && JSValueIsNumber(m_context, tnf_JSProperty)) {
 265                 props.tnf = static_cast<nfcTNF>(toLong(tnf_JSProperty));
 266         }
 267
 268         props.typeName= toVectorOfUChars(type_JSProperty);
 269         props.id= toVectorOfUChars(id_JSProperty);
 270
 271         return props;
 272 }
 273
 274 std::vector<void *> NFCConverter::toVectorOfRecordHandles(const JSValueRef& arg) {
 275     if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg)) {
 276                 ThrowMsg(Commons::InvalidArgumentException,
 277                          "NdefRecordArray is JS null or JS undefined.");
 278     }
 279
 280     if (!JSIsArrayValue(m_context, arg)) {
 281         ThrowMsg(Commons::ConversionException, "Argument is not an JS array.");
 282     }
 283
 284     std::vector<void *> result;
 285     JSObjectRef objArg = toJSObjectRef(arg);
 286     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); ++i) {
 287         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 288         result.push_back(getRecordHandle(element));
 289     }
 290     return result;
 291 }
 292
 293 void *NFCConverter::getRecordHandle(const JSValueRef& arg) {
 294         if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) ||
 295                 (!JSValueIsObjectOfClass(m_context, arg, JSNdefRecord::getClassRef()))) {
 296                 ThrowMsg(Commons::InvalidArgumentException,
 297                          "Message is JS null or JS undefined.");
 298         }
 299         JSObjectRef obj = toJSObjectRef(arg);
 300
 301         if (!obj) {
 302                 LogError("Object is null");
 303                 ThrowMsg(Commons::NullPointerException, "Private object not initialized");
 304         }
 305         NdefRecordPrivObject* privateObject = static_cast<NdefRecordPrivObject*>(JSObjectGetPrivate(obj));
 306         if (!privateObject) {
 307                 LogError("Private object is not set.");
 308                 ThrowMsg(Commons::NullPointerException, "Private object not initialized");
 309         }
 310
 311         INdefRecordPtr record = privateObject->getObject();
 312
 313         return record->getHandle();
 314 }
 315
 316 void *NFCConverter::getMessageHandle(const JSValueRef& arg) {
 317         if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) ||
 318                 (!JSValueIsObjectOfClass(m_context, arg, JSNdefMessage::getClassRef()))) {
 319                 ThrowMsg(Commons::InvalidArgumentException,
 320                          "Message is JS null or JS undefined.");
 321         }
 322         JSObjectRef obj = toJSObjectRef(arg);
 323
 324         if (!obj) {
 325                 LogError("Object is null");
 326                 ThrowMsg(Commons::NullPointerException, "Private object not initialized");
 327         }
 328         NdefMessagePrivObject* privateObject = static_cast<NdefMessagePrivObject*>(JSObjectGetPrivate(obj));
 329         if (!privateObject) {
 330                 LogError("Private object is not set.");
 331                 ThrowMsg(Commons::NullPointerException, "Private object not initialized");
 332         }
 333
 334         INdefMessagePtr message = privateObject->getObject();
 335
 336         return message->getHandle();
 337 }
 338
 339 NFCChangedCallback NFCConverter::toNFCChangedCallback(const JSValueRef& arg) {
 340         LogDebug("Entered");
 341     JSObjectRef object = toJSObjectRef(arg);
 342
 343     NFCChangedCallback result;
 344     Validator validator(m_context);
 345
 346     result.onAttach= JSUtils::getJSPropertyOrUndefined(
 347             m_context, object, NFC_CHANGED_CALLBACK_ONATTATCH
 348             );
 349     if (!validator.isNullOrUndefined(result.onAttach) &&
 350         !validator.isCallback(result.onAttach)) {
 351         ThrowMsg(Commons::ConversionException, "Not a valid callback.");
 352     }
 353
 354     result.onDetach= JSUtils::getJSPropertyOrUndefined(
 355             m_context, object, NFC_CHANGED_CALLBACK_ONDETACH
 356             );
 357     if (!validator.isNullOrUndefined(result.onDetach) &&
 358         !validator.isCallback(result.onDetach)) {
 359         ThrowMsg(Commons::ConversionException, "Not a valid callback.");
 360     }
 361
 362     return result;
 363 }
 364
 365 }
 366 }