From: VBS Date: Wed, 29 Mar 2017 10:00:15 +0000 (+0900) Subject: Sync with 3.0 : Ver. 0.3.6 to 0.3.9 X-Git-Tag: accepted/tizen/unified/20170411.164450~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=65ca8a1851ae6e12c5ec138e41c0c69730af1a49;p=platform%2Fcore%2Fapi%2Fnfc.git Sync with 3.0 : Ver. 0.3.6 to 0.3.9 Signed-off-by: Jihoon Jung Change-Id: If566346482302d8b471a59d91994a013f31131d4 --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 6aae7e2..6bb16c3 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 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 index 0000000..4a2fad4 --- /dev/null +++ b/test/nfc_unit_test.c @@ -0,0 +1,265 @@ +#include +#include +#include +#include +#include + +#include + +#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(¤t_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(¤t_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; +}