path: root/src/standards/Tizen/NFC/NFCConverter.cpp

/*
 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */



#include <dpl/log/log.h>
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/ScopedJSStringRef.h>
#include <CommonsJavaScript/JSUtils.h>
#include "NFCConverter.h"
#include "JSNdefRecord.h"
#include "JSNdefMessage.h"

using namespace std;
using namespace TizenApis::Api::NFC;
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis;


#define NFC_FILTER_ATTRIBUTE_TAG_TYPES "tagTypes"

#define NFC_CHANGED_CALLBACK_ONATTATCH "onAttach"
#define NFC_CHANGED_CALLBACK_ONDETACH "onDetach"

namespace TizenApis {
namespace Tizen1_0 {

vector<std::string> NFCConverter::m_allowedTagFilterProperties;

NFCConverter::NFCConverter(JSContextRef context) : Converter(context)
{
    LogDebug("entered");
    static bool init = initializeAllowedProperties();
    (void) init;
}

NFCConverter::~NFCConverter()
{
    LogDebug("entered");
}

TagFilterPtr NFCConverter::toNFCTagFilter(JSValueRef jsValue)
{
    LogDebug("entered");
    if (JSValueIsNull(m_context, jsValue) ||
        JSValueIsUndefined(m_context, jsValue)) {
        return TagFilterPtr(); //empty filter
    }
    TagFilterPtr filter(new TagFilter());

    Validator validator(m_context);

    if (!JSValueIsUndefined(m_context, jsValue)) {
    	vector<std::string> filter_values(toVectorOfStrings(jsValue));

    	LogDebug("NFCConverter, start setting filter values, tag_types.size() : " << filter_values.size());
    	  for (unsigned int i=0; i<filter_values.size(); i++) {
		nfcTagType filterValue = toNfcTagType(filter_values.at(i));

		filter->addTagTypeValue(filterValue);
    		  LogDebug("NFCConverter,  tag_types.at(i): " << filter_values.at(i));
    	  }
    }
    LogDebug("NFCConverter,  filter size == " << filter->getFilterSize());

    return filter;
}


nfcTagType NFCConverter::toNfcTagType(std::string typeString) {
	if (typeString == "ISO14443_A")
		return NFC_TAGTYPE_ISO14443_A_PICC;
	else if (typeString == "ISO14443_4A")
		return NFC_TAGTYPE_ISO14443_4A_PICC;
	else if (typeString == "ISO14443_3A")
		return NFC_TAGTYPE_ISO14443_3A_PICC;
	else if (typeString == "MIFARE_MINI")
		return NFC_TAGTYPE_MIFARE_MINI_PICC;
	else if (typeString == "MIFARE_1K")
		return NFC_TAGTYPE_MIFARE_1K_PICC;
	else if (typeString == "MIFARE_4K")
		return NFC_TAGTYPE_MIFARE_4K_PICC;
	else if (typeString == "MIFARE_ULTRA")
		return NFC_TAGTYPE_MIFARE_ULTRA_PICC;
	else if (typeString == "MIFARE_DESFIRE")
		return NFC_TAGTYPE_MIFARE_DESFIRE_PICC;
	else if (typeString == "ISO14443_B")
		return NFC_TAGTYPE_ISO14443_B_PICC;
	else if (typeString == "ISO14443_4B")
		return NFC_TAGTYPE_ISO14443_4B_PICC;
	else if (typeString == "ISO14443_BPRIME")
		return NFC_TAGTYPE_ISO14443_BPRIME_PICC;
	else if (typeString == "FELICA")
		return NFC_TAGTYPE_FELICA_PICC;
	else if (typeString == "JEWEL")
		return NFC_TAGTYPE_JEWEL_PICC;
	else if (typeString == "ISO15693")
		return NFC_TAGTYPE_ISO15693_PICC;
	else
		ThrowMsg(Commons::InvalidArgumentException, "No Match Tag Type");
}

std::string NFCConverter::toNfcTagTypeString(nfcTagType type) {
	switch (type) {
		case NFC_TAGTYPE_GENERIC_PICC:
			return "GENERIC_TARGET";
			break;
		case NFC_TAGTYPE_ISO14443_A_PICC:
			return "ISO14443_A";
			break;
		case NFC_TAGTYPE_ISO14443_4A_PICC:
			return "ISO14443_4A";
			break;
		case NFC_TAGTYPE_ISO14443_3A_PICC:
			return "ISO14443_3A";
			break;
		case NFC_TAGTYPE_MIFARE_MINI_PICC:
			return "MIFARE_MINI";
			break;
		case NFC_TAGTYPE_MIFARE_1K_PICC:
			return "MIFARE_1K";
			break;
		case NFC_TAGTYPE_MIFARE_4K_PICC:
			return "MIFARE_4K";
			break;
		case NFC_TAGTYPE_MIFARE_ULTRA_PICC:
			return "MIFARE_ULTRA";
			break;
		case NFC_TAGTYPE_MIFARE_DESFIRE_PICC:
			return "MIFARE_DESFIRE";
			break;
		case NFC_TAGTYPE_ISO14443_B_PICC:
			return "ISO14443_B";
			break;
		case NFC_TAGTYPE_ISO14443_4B_PICC:
			return "ISO14443_4B";
			break;
		case NFC_TAGTYPE_ISO14443_BPRIME_PICC:
			return "ISO14443_BPRIME";
			break;
		case NFC_TAGTYPE_FELICA_PICC:
			return "FELICA";
			break;
		case NFC_TAGTYPE_JEWEL_PICC:
			return "JEWEL";
			break;
		case NFC_TAGTYPE_ISO15693_PICC:
			return "ISO15693";
			break;
		case NFC_TAGTYPE_UNKNOWN_TARGET:
		default:
			return "UNKNOWN_TARGET";
			break;
	}
}

nfcTextEncodeUTF NFCConverter::toNfcTextEncodeUTF(std::string encodeString) {
	if (encodeString == "UTF-8")
		return NFC_TEXT_ENCODE_UTF_8;
	else if (encodeString == "UTF-16")
		return NFC_TEXT_ENCODE_UTF_16;
	else
		Throw(ConversionException);
}

std::string NFCConverter::toNfcTextEncodeUTFString(nfcTextEncodeUTF encode) {
	switch(encode) {
		case NFC_TEXT_ENCODE_UTF_8:
			return "UTF-8";
			break;
		case NFC_TEXT_ENCODE_UTF_16:
			return "UTF-16";
			break;
		default:
			Throw(ConversionException);
	}
}
bool NFCConverter::initializeAllowedProperties()
{
    LogDebug("entered");
    //NFC Filter properties
    m_allowedTagFilterProperties.push_back(NFC_FILTER_ATTRIBUTE_TAG_TYPES);
     return true;
}

JSValueRef NFCConverter::toJSValueRef(const std::vector<unsigned char>& arg) {
    JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);

    if (NULL == jsResult) {
        ThrowMsg(Commons::NullPointerException, "Could not create js array object");
    }

    for (std::size_t i = 0; i < arg.size(); ++i) {
        JSValueRef tmpVal = JSValueMakeNumber(m_context, arg[i]);
        if (!JSSetArrayElement(m_context, jsResult, i, tmpVal)) {
            ThrowMsg(Commons::UnknownException, "Could not insert value into js array");
        }
    }

    return jsResult;
}

JSValueRef NFCConverter::toJSValueRef(NdefRecordProperties props) {
	JSObjectRef propertyRef = JSObjectMake(m_context, NULL, NULL);
	
	ScopedJSStringRef jsTNFString(JSStringCreateWithUTF8CString("tnf"));
	ScopedJSStringRef jsTypeString(JSStringCreateWithUTF8CString("typeName"));
	ScopedJSStringRef jsIdString(JSStringCreateWithUTF8CString("id"));
	
	JSObjectSetProperty(m_context, propertyRef, jsTNFString.get(), toJSValueRef(static_cast<int>(props.tnf)), kJSPropertyAttributeNone, NULL);
	JSObjectSetProperty(m_context, propertyRef, jsTypeString.get(), toJSValueRef(props.typeName), kJSPropertyAttributeNone, NULL);
	JSObjectSetProperty(m_context, propertyRef, jsIdString.get(), toJSValueRef(props.id), kJSPropertyAttributeNone, NULL);

	return propertyRef;
}

JSValueRef NFCConverter::toJSValueRef(std::vector<NFCTagProperties> props) {
	JSObjectRef jsResult = JSCreateArrayObject(m_context, 0, NULL);
	if (NULL == jsResult) {
		ThrowMsg(WrtDeviceApis::Commons::NullPointerException,
		         "Could not create js array object");
	}

	for (std::size_t i = 0; i < props.size(); ++i) {
		JSValueRef tmpVal = toJSValueRef(props[i].value);
		if (!JSSetArrayElementInArrayList(m_context, jsResult, props[i].key.c_str(), tmpVal)) {
			ThrowMsg(WrtDeviceApis::Commons::UnknownException,
			         "Could not insert value into js array");
		}
	}
	return jsResult;
}

NdefRecordProperties NFCConverter::toNdefRecordProperties(JSValueRef value, JSValueRef* exception) {
	if (JSValueIsNull(m_context, value) || JSValueIsUndefined(m_context, value)) {
		ThrowMsg(Commons::InvalidArgumentException,
		         "Message is JS null or JS undefined.");
	}
	JSObjectRef obj = toJSObjectRef(value);
	
	if (!obj) {
		LogError("Object is null");
		ThrowMsg(Commons::NullPointerException, "Private object not initialized");
	}
	
	NdefRecordProperties props;
	JSValueRef tnf_JSProperty = JSUtils::getJSProperty(m_context, value, "tnf", exception);
	JSValueRef type_JSProperty = JSUtils::getJSProperty(m_context, value, "typeName", exception);
	JSValueRef id_JSProperty = JSUtils::getJSProperty(m_context, value, "id", exception);

	if (tnf_JSProperty != NULL && JSValueIsNumber(m_context, tnf_JSProperty)) {
		props.tnf = static_cast<nfcTNF>(toLong(tnf_JSProperty));
	}

	props.typeName= toVectorOfUChars(type_JSProperty);
	props.id= toVectorOfUChars(id_JSProperty);

	return props;
}

std::vector<void *> NFCConverter::toVectorOfRecordHandles(const JSValueRef& arg) {
    if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg)) {
		ThrowMsg(Commons::InvalidArgumentException,
		         "NdefRecordArray is JS null or JS undefined.");
    }

    if (!JSIsArrayValue(m_context, arg)) {
        ThrowMsg(Commons::ConversionException, "Argument is not an JS array.");
    }

    std::vector<void *> result;
    JSObjectRef objArg = toJSObjectRef(arg);
    for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); ++i) {
        JSValueRef element = JSGetArrayElement(m_context, objArg, i);
        result.push_back(getRecordHandle(element));
    }
    return result;
}

void *NFCConverter::getRecordHandle(const JSValueRef& arg) {
	if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) ||
		(!JSValueIsObjectOfClass(m_context, arg, JSNdefRecord::getClassRef()))) {
		ThrowMsg(Commons::InvalidArgumentException,
		         "Message is JS null or JS undefined.");
	}
	JSObjectRef obj = toJSObjectRef(arg);
	
	if (!obj) {
		LogError("Object is null");
		ThrowMsg(Commons::NullPointerException, "Private object not initialized");
	}
	NdefRecordPrivObject* privateObject = static_cast<NdefRecordPrivObject*>(JSObjectGetPrivate(obj));
	if (!privateObject) {
		LogError("Private object is not set.");
		ThrowMsg(Commons::NullPointerException, "Private object not initialized");
	}

	INdefRecordPtr record = privateObject->getObject();

	return record->getHandle();
}

void *NFCConverter::getMessageHandle(const JSValueRef& arg) {
	if (JSValueIsNull(m_context, arg) || JSValueIsUndefined(m_context, arg) ||
		(!JSValueIsObjectOfClass(m_context, arg, JSNdefMessage::getClassRef()))) {
		ThrowMsg(Commons::InvalidArgumentException,
		         "Message is JS null or JS undefined.");
	}
	JSObjectRef obj = toJSObjectRef(arg);
	
	if (!obj) {
		LogError("Object is null");
		ThrowMsg(Commons::NullPointerException, "Private object not initialized");
	}
	NdefMessagePrivObject* privateObject = static_cast<NdefMessagePrivObject*>(JSObjectGetPrivate(obj));
	if (!privateObject) {
		LogError("Private object is not set.");
		ThrowMsg(Commons::NullPointerException, "Private object not initialized");
	}

	INdefMessagePtr message = privateObject->getObject();

	return message->getHandle();
}

NFCChangedCallback NFCConverter::toNFCChangedCallback(const JSValueRef& arg) {
	LogDebug("Entered");
    JSObjectRef object = toJSObjectRef(arg);

    NFCChangedCallback result;
    Validator validator(m_context);

    result.onAttach= JSUtils::getJSPropertyOrUndefined(
            m_context, object, NFC_CHANGED_CALLBACK_ONATTATCH
            );
    if (!validator.isNullOrUndefined(result.onAttach) &&
        !validator.isCallback(result.onAttach)) {
        ThrowMsg(Commons::ConversionException, "Not a valid callback.");
    }

    result.onDetach= JSUtils::getJSPropertyOrUndefined(
            m_context, object, NFC_CHANGED_CALLBACK_ONDETACH
            );
    if (!validator.isNullOrUndefined(result.onDetach) &&
        !validator.isCallback(result.onDetach)) {
        ThrowMsg(Commons::ConversionException, "Not a valid callback.");
    }

    return result;
}

}
}