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