Sync with 3.0 : Ver. 0.3.6 to 0.3.9

Signed-off-by: Jihoon Jung <jh8801.jung@samsung.com>
Change-Id: If566346482302d8b471a59d91994a013f31131d4

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6aae7e2..6bb16c3 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,6 +88,8 @@ CONFIGURE_FILE(
 )
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIBDIR}/pkgconfig)
 
+ADD_SUBDIRECTORY(test)
+
 IF(UNIX)
 
 ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)

diff --git a/include/nfc_common.h b/include/nfc_common.h
index ea4712f..9009a26 100755 (executable)
--- a/include/nfc_common.h
+++ b/include/nfc_common.h
@@ -152,6 +152,12 @@ typedef struct _nfc_activation_data_s
        void *user_data;
 } nfc_activation_data_s;
 
+typedef struct _nfc_callback_s
+{
+       void *callback;
+       void *user_data;
+} nfc_callback_s;
+
 extern _nfc_context_s gdbus_nfc_context;
 
 pid_t nfc_common_get_focus_app_pid();

diff --git a/packaging/capi-network-nfc.spec b/packaging/capi-network-nfc.spec
index 5d64c5f..66b0aad 100644 (file)
--- a/packaging/capi-network-nfc.spec
+++ b/packaging/capi-network-nfc.spec
@@ -1,6 +1,6 @@
 Name:       capi-network-nfc
 Summary:    A NFC library in Native API
-Version:    0.3.6
+Version:    0.3.9
 Release:    0
 Group:      Network & Connectivity/NFC
 License:    Apache-2.0
@@ -47,8 +47,6 @@ make %{?jobs:-j%jobs}
 
 %install
 rm -rf %{buildroot}
-mkdir -p %{buildroot}/usr/share/license
-cp -af %{_builddir}/%{name}-%{version}/packaging/capi-network-nfc %{buildroot}/usr/share/license/
 
 %make_install
 
@@ -59,8 +57,8 @@ cp -af %{_builddir}/%{name}-%{version}/packaging/capi-network-nfc %{buildroot}/u
 
 %files
 %manifest capi-network-nfc.manifest
+%license LICENSE.APLv2
 %{_libdir}/libcapi-network-nfc.so*
-/usr/share/license/capi-network-nfc
 
 %files devel
 %{_includedir}/network/*.h

diff --git a/src/net_nfc_client_hce_ipc.c b/src/net_nfc_client_hce_ipc.c
index a6773a8..b826227 100755 (executable)
--- a/src/net_nfc_client_hce_ipc.c
+++ b/src/net_nfc_client_hce_ipc.c
@@ -141,7 +141,7 @@ static bool __send_data_to_server(int socket, data_s *data)
 {
        ssize_t ret;
 
-       ret = send(socket, data->buffer, data->length, 0);
+       ret = send(socket, data->buffer, data->length, MSG_NOSIGNAL);
        if (ret == -1) {
                DEBUG_ERR_MSG("send failed, socket [%d]", socket);
 

diff --git a/src/net_nfc_client_llcp.c b/src/net_nfc_client_llcp.c
index 488c7bb..7aa3214 100755 (executable)
--- a/src/net_nfc_client_llcp.c
+++ b/src/net_nfc_client_llcp.c
@@ -1914,6 +1914,8 @@ void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 
        if (socket)
                *socket = socket_data->client_socket;
+
+       _net_nfc_util_free_mem(socket_data);
 }
 
 

diff --git a/src/nfc_tag.c b/src/nfc_tag.c
index ec93f2e..4e3251f 100755 (executable)
--- a/src/nfc_tag.c
+++ b/src/nfc_tag.c
@@ -41,27 +41,22 @@ const unsigned char NFC_TAG_MIFARE_KEY_NFC_FORUM[6] = {0xD3, 0xF7, 0xD3, 0xF7, 0
 static void _tag_format_ndef_cb(net_nfc_error_e result,
        void *user_data)
 {
-       nfc_tag_format_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_tag_format_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_tag_format_completed_cb)user_param->callback;
 
-       if (callback != NULL) {
-               callback(nfc_common_convert_error_code(__func__, result),
-                       user_param);
-       }
+       if (callback != NULL)
+               callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -91,19 +86,21 @@ int nfc_tag_format_ndef(nfc_tag_h tag,
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
                        &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_ndef_format(
                                        handle,
                                        key_data,
                                        _tag_format_ndef_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -124,20 +121,17 @@ int nfc_tag_format_ndef(nfc_tag_h tag,
 static void _tag_read_ndef_cb(net_nfc_error_e result, ndef_message_h message,
        void *user_data)
 {
-       nfc_tag_read_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_tag_read_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_tag_read_completed_cb)user_param->callback;
 
        if (callback != NULL) {
                callback(nfc_common_convert_error_code(__func__, result),
@@ -145,7 +139,7 @@ static void _tag_read_ndef_cb(net_nfc_error_e result, ndef_message_h message,
                        user_param);
        }
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -165,18 +159,20 @@ int nfc_tag_read_ndef(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_ndef_read(
                                handle,
                                _tag_read_ndef_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -192,25 +188,22 @@ int nfc_tag_read_ndef(nfc_tag_h tag,
 static void _tag_write_ndef_cb(net_nfc_error_e result,
        void *user_data)
 {
-       nfc_tag_write_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_tag_write_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_tag_write_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -259,19 +252,21 @@ int nfc_tag_write_ndef(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_ndef_write(
                                handle,
                                msg,
                                _tag_write_ndef_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -287,18 +282,17 @@ int nfc_tag_write_ndef(nfc_tag_h tag,
 static void _tag_transceive_data_cb(net_nfc_error_e result, data_h arg_data,
        void *user_data)
 {
-       nfc_tag_transceive_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_tag_transceive_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL)
+       if (user_param == NULL) {
+               LOG_ERR("user_data is NULL");
                return;
+       }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_tag_transceive_completed_cb)user_param->callback;
 
        if (callback != NULL) {
                uint8_t *buffer = NULL;
@@ -315,7 +309,7 @@ static void _tag_transceive_data_cb(net_nfc_error_e result, data_h arg_data,
                        user_param);
        }
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -344,19 +338,21 @@ int nfc_tag_transceive(nfc_tag_h tag,
 
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_transceive_data(
                                        handle,
                                        rawdata,
                                        _tag_transceive_data_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -495,25 +491,22 @@ int nfc_tag_foreach_information(nfc_tag_h tag,
 static void _mifare_authenticate_with_keyA_cb(net_nfc_error_e result,
        void *user_data)
 {
-       nfc_mifare_authenticate_with_keyA_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_authenticate_with_keyA_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_authenticate_with_keyA_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -540,12 +533,14 @@ int nfc_mifare_authenticate_with_keyA(nfc_tag_h tag,
 
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_mifare_authenticate_with_keyA(
                                        handle,
                                        sector_index,
@@ -553,7 +548,7 @@ int nfc_mifare_authenticate_with_keyA(nfc_tag_h tag,
                                        _mifare_authenticate_with_keyA_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -575,23 +570,22 @@ int nfc_mifare_authenticate_with_keyA(nfc_tag_h tag,
 static void _mifare_authenticate_with_keyB_cb(net_nfc_error_e result,
        void *user_data)
 {
-       nfc_mifare_authenticate_with_keyB_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_authenticate_with_keyB_completed_cb callback = NULL;
 
-       if (user_data == NULL) {
+       LOG_BEGIN();
+
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_authenticate_with_keyB_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -620,12 +614,14 @@ int nfc_mifare_authenticate_with_keyB(nfc_tag_h tag,
 
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_mifare_authenticate_with_keyB(
                                        handle,
                                        sector_index,
@@ -633,7 +629,7 @@ int nfc_mifare_authenticate_with_keyB(nfc_tag_h tag,
                                        _mifare_authenticate_with_keyB_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -655,18 +651,17 @@ int nfc_mifare_authenticate_with_keyB(nfc_tag_h tag,
 static void _mifare_read_block_cb(net_nfc_error_e result, data_h data,
        void *user_data)
 {
+       nfc_callback_s *user_param = user_data;
        nfc_mifare_read_block_completed_cb callback;
-       void *user_param;
 
-       if (user_data == NULL) {
+       LOG_BEGIN();
+
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_read_block_completed_cb)user_param->callback;
 
        if (callback != NULL) {
                uint8_t *buffer = NULL;
@@ -683,7 +678,7 @@ static void _mifare_read_block_cb(net_nfc_error_e result, data_h data,
                        user_param);
        }
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -705,19 +700,21 @@ int nfc_mifare_read_block(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_mifare_read(
                                handle,
                                block_index,
                                _mifare_read_block_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -745,9 +742,9 @@ int nfc_mifare_read_page(nfc_tag_h tag,
        CHECK_INIT();
        CHECK_INVALID(tag == NULL);
 
-       parameter = g_variant_new("(tt)",
-               callback,
-               user_data);
+       parameter = g_variant_new("(uu)",
+               GPOINTER_TO_UINT(callback),
+               GPOINTER_TO_UINT(user_data));
        if (parameter != NULL) {
                g_variant_unref(parameter);
                ret = NET_NFC_OK;
@@ -762,25 +759,22 @@ int nfc_mifare_read_page(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_write_block_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_write_block_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_write_block_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_write_block_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -812,12 +806,14 @@ int nfc_mifare_write_block(nfc_tag_h tag,
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
                        &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_mifare_write_block(
                                        handle,
                                        block_index,
@@ -825,7 +821,7 @@ int nfc_mifare_write_block(nfc_tag_h tag,
                                        _mifare_write_block_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -845,25 +841,22 @@ int nfc_mifare_write_block(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_write_page_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_write_page_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_write_page_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_write_page_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -894,12 +887,14 @@ int nfc_mifare_write_page(nfc_tag_h tag,
                ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
                        &handle);
                if (ret == NET_NFC_OK) {
-                       GVariant *parameter;
+                       nfc_callback_s *parameter = NULL;
+
+                       parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-                       parameter = g_variant_new("(tt)",
-                               callback,
-                               user_data);
                        if (parameter != NULL) {
+                               parameter->callback = callback;
+                               parameter->user_data = user_data;
+
                                ret = net_nfc_client_mifare_write_page(
                                        handle,
                                        page_index,
@@ -907,7 +902,7 @@ int nfc_mifare_write_page(nfc_tag_h tag,
                                        _mifare_write_page_cb,
                                        parameter);
                                if (ret != NET_NFC_OK)
-                                       g_variant_unref(parameter);
+                                       free(parameter);
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -927,25 +922,22 @@ int nfc_mifare_write_page(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_increment_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_increment_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_increment_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_increment_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -969,12 +961,14 @@ int nfc_mifare_increment(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_mifare_increment(
                                handle,
                                block_index,
@@ -982,7 +976,7 @@ int nfc_mifare_increment(nfc_tag_h tag,
                                _mifare_increment_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -997,25 +991,22 @@ int nfc_mifare_increment(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_decrement_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_decrement_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_decrement_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_decrement_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -1039,12 +1030,14 @@ int nfc_mifare_decrement(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_mifare_decrement(
                                handle,
                                block_index,
@@ -1052,7 +1045,7 @@ int nfc_mifare_decrement(nfc_tag_h tag,
                                _mifare_decrement_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -1067,25 +1060,22 @@ int nfc_mifare_decrement(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_transfer_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_transfer_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_transfer_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_transfer_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -1108,19 +1098,21 @@ int nfc_mifare_transfer(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_mifare_transfer(
                                handle,
                                block_index,
                                _mifare_transfer_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -1135,25 +1127,22 @@ int nfc_mifare_transfer(nfc_tag_h tag,
 /* LCOV_EXCL_START */
 static void _mifare_restore_cb(net_nfc_error_e result, void *user_data)
 {
-       nfc_mifare_restore_completed_cb callback;
-       void *user_param;
+       nfc_callback_s *user_param = user_data;
+       nfc_mifare_restore_completed_cb callback = NULL;
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_param == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
 
-       g_variant_get((GVariant *)user_data,
-               "(tt)",
-               &callback,
-               &user_param);
+       callback = (nfc_mifare_restore_completed_cb)user_param->callback;
 
        if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
 
-       g_variant_unref((GVariant *)user_data);
+       free(user_param);
 }
 /* LCOV_EXCL_STOP */
 
@@ -1176,19 +1165,21 @@ int nfc_mifare_restore(nfc_tag_h tag,
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
-               GVariant *parameter;
+               nfc_callback_s *parameter = NULL;
+
+               parameter = (nfc_callback_s *)malloc(sizeof(nfc_callback_s));
 
-               parameter = g_variant_new("(tt)",
-                       callback,
-                       user_data);
                if (parameter != NULL) {
+                       parameter->callback = callback;
+                       parameter->user_data = user_data;
+
                        ret = net_nfc_client_mifare_restore(
                                handle,
                                block_index,
                                _mifare_restore_cb,
                                parameter);
                        if (ret != NET_NFC_OK)
-                               g_variant_unref(parameter);
+                               free(parameter);
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100755 (executable)
index 0000000..5c3e5cc
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,18 @@
+SET(fw_test "nfc-test")
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_test} REQUIRED dlog glib-2.0)
+FOREACH(flag ${${fw_test}_CFLAGS})
+    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+    MESSAGE(${flag})
+ENDFOREACH()
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall")
+
+aux_source_directory(. sources)
+FOREACH(src ${sources})
+    GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
+    MESSAGE("${src_name}")
+    ADD_EXECUTABLE(${src_name} ${src})
+    TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS})
+ENDFOREACH()

diff --git a/test/nfc_unit_test.c b/test/nfc_unit_test.c
new file mode 100755 (executable)
index 0000000..4a2fad4
--- /dev/null
+++ b/test/nfc_unit_test.c
@@ -0,0 +1,265 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <unistd.h>
+
+#include <nfc.h>
+
+#define BUFFER_LEN 10
+#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
+#define TC_PRT(format, args...) PRT(format"\n", ##args)
+
+GMainLoop *main_loop = NULL;
+
+typedef struct {
+       const char *tc_name;
+       int tc_code;
+} tc_table_t;
+
+tc_table_t tc_table[] = {
+       /* manage api*/
+       {"NFC Initialize Test", 1},
+       {"NFC Tag NDEF Read", 2},
+       {"NFC Tag NDEF Write", 3},
+       {"NFC Deinitialize Test", 4},
+
+       /* -----------*/
+       {"Finish"               , 0x00ff},
+       {NULL                   , 0x0000},
+};
+
+void tc_usage_print(void)
+{
+       int i = 0;
+
+       while (tc_table[i].tc_name) {
+               if (tc_table[i].tc_code != 0x00ff)
+                       TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
+               else
+                       TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
+
+               i++;
+       }
+}
+
+void __tag_read_completed(nfc_error_e result, nfc_ndef_message_h message, void *user_data)
+{
+       if (result == NFC_ERROR_NONE) {
+               int count = 0;
+               nfc_ndef_message_get_record_count(message, &count);
+               TC_PRT("tag read successful");
+               TC_PRT("record count : %d", count);
+
+               if (count > 0) {
+                       nfc_ndef_record_h record = NULL;
+                       nfc_ndef_message_get_record(message, 0, &record);
+
+                       if (record != NULL) {
+                               char *lang_code = NULL;
+                               int id_size = 0;
+                               int type_size = 0;
+                               unsigned char *id = NULL;
+                               unsigned char *type = NULL;
+                               TC_PRT("----* record 0 information start *----");
+                               nfc_ndef_record_get_langcode(record, &lang_code);
+                               TC_PRT("1. lang_code : %s", lang_code);
+
+                               nfc_ndef_record_get_id(record, &id, &id_size);
+                               TC_PRT("2. id : %s, id_size : %d", id, id_size);
+
+                               nfc_ndef_record_get_type(record, &type, &type_size);
+                               TC_PRT("3. type : %s, type_size : %d", type, type_size);
+
+                               if (strcmp((const char *)type, "T") == 0) {
+                                       char* text = NULL;
+                                       nfc_ndef_record_get_text(record, &text);
+
+                                       TC_PRT("3. This record is Text record.");
+                                       TC_PRT("3. Stored text : %s", text);
+                               }
+
+                               TC_PRT("----* record 0 information end *----");
+                       }
+               }
+       } else {
+               TC_PRT("tag read error : %d", result);
+       }
+}
+
+void __tag_write_completed(nfc_error_e result, void *user_data)
+{
+       if (result == NFC_ERROR_NONE)
+               TC_PRT("tag write successful");
+       else
+               TC_PRT("tag write error : %d", result);
+}
+
+void __tag_discovered(nfc_discovered_type_e type, nfc_tag_h tag, void *user_data)
+{
+       if (type == NFC_DISCOVERED_TYPE_ATTACHED) {
+               nfc_tag_type_e tag_type = NFC_UNKNOWN_TARGET;
+               bool is_support_ndef = false;
+
+               TC_PRT("tag discovered!!!");
+
+               nfc_tag_get_type(tag, &tag_type);
+               TC_PRT("tag type is %d", tag_type);
+
+               nfc_tag_is_support_ndef(tag, &is_support_ndef);
+               TC_PRT("NDEF is supported? : %d", is_support_ndef);
+
+       } else if (type == NFC_DISCOVERED_TYPE_DETACHED) {
+               TC_PRT("tag detached!!!");
+       }
+}
+
+char* nfc_util_itoa(char* fmt, ...)
+{
+       char str[128];
+       va_list arguments;
+       va_start(arguments, fmt);
+       vsnprintf(str, sizeof(str), fmt, arguments);
+       va_end(arguments);
+
+       return strdup(str);
+}
+
+nfc_ndef_message_h __create_ndef_message()
+{
+       nfc_ndef_message_h msg = NULL;
+       nfc_ndef_record_h ndef_name_record = NULL;
+       unsigned int seed = time(NULL);
+       char* time_str = nfc_util_itoa("The random text : %d", rand_r(&seed));
+
+       nfc_ndef_message_create(&msg);
+       nfc_ndef_record_create_text(&ndef_name_record, time_str, "en-US", NFC_ENCODE_UTF_8);
+       nfc_ndef_message_append_record(msg, ndef_name_record);
+       TC_PRT("Text : %s", time_str);
+
+       return msg;
+}
+
+int test_input_callback(void *data)
+{
+       int ret = 0;
+       long test_id = (long)data;
+
+       switch (test_id) {
+       case 0x00ff:
+               TC_PRT("Finished");
+               g_main_loop_quit(main_loop);
+               break;
+       case 1:
+               {
+                       TC_PRT("nfc initialize start");
+                       ret = nfc_manager_initialize();
+                       if (ret == NFC_ERROR_NONE)
+                               TC_PRT("NFC Initialize successful");
+                       else
+                               TC_PRT("NFC Error occur : %d", ret);
+
+                       nfc_manager_set_tag_discovered_cb(__tag_discovered, NULL);
+                       TC_PRT("nfc initialize end");
+               }
+               break;
+       case 2:
+               {
+                       TC_PRT("Tag read start");
+                       nfc_tag_h current_tag = NULL;
+                       nfc_manager_get_connected_tag(&current_tag);
+
+                       if (current_tag != NULL)
+                               ret = nfc_tag_read_ndef(current_tag, __tag_read_completed, NULL);
+                       else
+                               TC_PRT("Tag Not Connected");
+
+                       TC_PRT("Tag read end");
+               }
+               break;
+       case 3:
+               {
+                       TC_PRT("Tag write start");
+
+                       nfc_tag_h current_tag = NULL;
+                       nfc_manager_get_connected_tag(&current_tag);
+                       nfc_ndef_message_h msg = __create_ndef_message();
+
+                       if (msg != NULL) {
+                               if (current_tag != NULL)
+                                       ret = nfc_tag_write_ndef(current_tag, msg, __tag_write_completed, NULL);
+                               else
+                                       TC_PRT("Tag Not Connected.");
+                       } else {
+                               TC_PRT("NDEF Message create is failed.");
+                       }
+
+                       TC_PRT("Tag write end");
+               }
+               break;
+       case 4:
+               {
+                       TC_PRT("nfc deinitialize start");
+
+                       ret = nfc_manager_deinitialize();
+                       if (ret == NFC_ERROR_NONE)
+                               TC_PRT("NFC Deinitialize successful");
+                       else
+                               TC_PRT("NFC Error occur : %d", ret);
+
+                       TC_PRT("nfc deinitialize end");
+               }
+               break;
+       default:
+               tc_usage_print();
+               break;
+       }
+
+       return 0;
+}
+
+static gboolean key_event_cb(GIOChannel *chan,
+               GIOCondition cond,
+               gpointer data)
+{
+       char buf[BUFFER_LEN] = { 0 };
+
+       gsize len = 0;
+       long test_id;
+
+       memset(buf, 0, sizeof(buf));
+
+       if (g_io_channel_read_chars(chan, buf, sizeof(buf), &len, NULL) == G_IO_STATUS_ERROR)
+               return FALSE;
+
+       test_id = atoi(buf);
+
+       if (test_id)
+               g_idle_add(test_input_callback, (void *)test_id);
+
+       return TRUE;
+}
+
+
+int main(int argc, char ** argv)
+{
+       GIOChannel *key_io;
+
+       tc_usage_print();
+
+       key_io = g_io_channel_unix_new(fileno(stdin));
+
+       g_io_channel_set_encoding(key_io, NULL, NULL);
+       g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
+
+       g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+               key_event_cb, NULL);
+
+       g_io_channel_unref(key_io);
+
+       main_loop = g_main_loop_new(NULL, FALSE);
+
+       g_main_loop_run(main_loop);
+
+       return 0;
+}