2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "nfc_common.h"
20 * @brief The default factory key.
21 * @details The key is 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
22 * @ingroup CAPI_NETWORK_NFC_TAG_MIFARE_MODULE
24 const unsigned char NFC_TAG_MIFARE_KEY_DEFAULT[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
27 * @brief The well-known key for tags formatted according to the MIFARE Application Directory (MAD) specification.
28 * @details The key is 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
29 * @ingroup CAPI_NETWORK_NFC_TAG_MIFARE_MODULE
31 const unsigned char NFC_TAG_MIFARE_KEY_APPLICATION_DIRECTORY[6] = {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5};
34 * @brief The well-known key for tags formatted according to the NDEF on Mifare Classic specification.
35 * @details The key is 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7
36 * @ingroup CAPI_NETWORK_NFC_TAG_MIFARE_MODULE
38 const unsigned char NFC_TAG_MIFARE_KEY_NFC_FORUM[6] = {0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7};
41 static void _tag_format_ndef_cb(net_nfc_error_e result,
44 nfc_tag_format_completed_cb callback;
49 if (user_data == NULL) {
50 LOG_ERR("user_data is NULL");
54 g_variant_get((GVariant *)user_data,
59 if (callback != NULL) {
60 callback(nfc_common_convert_error_code(__func__, result),
64 g_variant_unref((GVariant *)user_data);
68 int nfc_tag_format_ndef(nfc_tag_h tag,
71 nfc_tag_format_completed_cb callback,
75 data_h key_data = NULL;
79 CHECK_SUPPORTED(NFC_TAG_FEATURE);
83 CHECK_INVALID(tag == NULL);
85 CHECK_APP_PERMISSION();
87 ret = net_nfc_create_data(&key_data, key, key_size);
88 if (ret == NET_NFC_OK) {
89 net_nfc_target_handle_h handle = NULL;
91 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
93 if (ret == NET_NFC_OK) {
96 parameter = g_variant_new("(tt)",
99 if (parameter != NULL) {
100 ret = net_nfc_client_ndef_format(
105 if (ret != NET_NFC_OK)
106 g_variant_unref(parameter);
108 ret = NET_NFC_ALLOC_FAIL;
111 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
114 net_nfc_free_data(key_data);
116 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
119 return nfc_common_convert_error_code(__func__, ret);
123 /* LCOV_EXCL_START */
124 static void _tag_read_ndef_cb(net_nfc_error_e result, ndef_message_h message,
127 nfc_tag_read_completed_cb callback;
132 if (user_data == NULL) {
133 LOG_ERR("user_data is NULL");
137 g_variant_get((GVariant *)user_data,
142 if (callback != NULL) {
143 callback(nfc_common_convert_error_code(__func__, result),
144 (nfc_ndef_message_h)message,
148 g_variant_unref((GVariant *)user_data);
152 int nfc_tag_read_ndef(nfc_tag_h tag,
153 nfc_tag_read_completed_cb callback,
157 net_nfc_target_handle_h handle = NULL;
159 CHECK_SUPPORTED(NFC_TAG_FEATURE);
161 /* LCOV_EXCL_START */
163 CHECK_INVALID(tag == NULL);
166 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
167 if (ret == NET_NFC_OK) {
170 parameter = g_variant_new("(tt)",
173 if (parameter != NULL) {
174 ret = net_nfc_client_ndef_read(
178 if (ret != NET_NFC_OK)
179 g_variant_unref(parameter);
181 ret = NET_NFC_ALLOC_FAIL;
184 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
187 return nfc_common_convert_error_code(__func__, ret);
191 /* LCOV_EXCL_START */
192 static void _tag_write_ndef_cb(net_nfc_error_e result,
195 nfc_tag_write_completed_cb callback;
200 if (user_data == NULL) {
201 LOG_ERR("user_data is NULL");
205 g_variant_get((GVariant *)user_data,
210 if (callback != NULL)
211 callback(nfc_common_convert_error_code(__func__, result), user_param);
213 g_variant_unref((GVariant *)user_data);
217 int nfc_tag_write_ndef(nfc_tag_h tag,
218 nfc_ndef_message_h msg,
219 nfc_tag_write_completed_cb callback,
223 net_nfc_target_handle_h handle = NULL;
224 unsigned int byte_size = 0;
225 uint32_t max_len = 0;
226 net_nfc_ndef_card_state_e state = NET_NFC_NDEF_CARD_INVALID;
228 CHECK_SUPPORTED(NFC_TAG_FEATURE);
230 /* LCOV_EXCL_START */
232 CHECK_INVALID(tag == NULL);
234 CHECK_APP_PERMISSION();
236 ret = net_nfc_get_tag_ndef_state((net_nfc_target_info_h)tag, &state);
237 if (ret != NET_NFC_OK) {
238 LOG_ERR("net_nfc_get_tag_ndef_state failed, [%d]", ret);
239 return nfc_common_convert_error_code(__func__, ret);;
242 if (state == NET_NFC_NDEF_CARD_READ_ONLY)
243 return NFC_ERROR_READ_ONLY_NDEF;
245 ret = net_nfc_get_tag_max_data_size((net_nfc_target_info_h)tag, &max_len);
246 if (ret != NET_NFC_OK) {
247 LOG_ERR("net_nfc_get_tag_max_data_size failed, [%d]", ret);
248 return nfc_common_convert_error_code(__func__, ret);;
251 ret = nfc_common_get_rawdata_size(msg, &byte_size);
252 if (ret != NFC_ERROR_NONE) {
253 LOG_ERR("nfc_ndef_message_get_rawdata_size failed, [%d]", ret);
254 return nfc_common_convert_error_code(__func__, ret);;
257 if (max_len < byte_size)
258 return NFC_ERROR_NO_SPACE_ON_NDEF;
260 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
261 if (ret == NET_NFC_OK) {
264 parameter = g_variant_new("(tt)",
267 if (parameter != NULL) {
268 ret = net_nfc_client_ndef_write(
273 if (ret != NET_NFC_OK)
274 g_variant_unref(parameter);
276 ret = NET_NFC_ALLOC_FAIL;
279 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
282 return nfc_common_convert_error_code(__func__, ret);
286 /* LCOV_EXCL_START */
287 static void _tag_transceive_data_cb(net_nfc_error_e result, data_h arg_data,
290 nfc_tag_transceive_completed_cb callback;
295 if (user_data == NULL)
298 g_variant_get((GVariant *)user_data,
303 if (callback != NULL) {
304 uint8_t *buffer = NULL;
307 if (result == NET_NFC_OK && arg_data != NULL) {
308 buffer = net_nfc_get_data_buffer(arg_data);
309 length = net_nfc_get_data_length(arg_data);
312 callback(nfc_common_convert_error_code(__func__, result),
318 g_variant_unref((GVariant *)user_data);
322 int nfc_tag_transceive(nfc_tag_h tag,
323 unsigned char *buffer,
325 nfc_tag_transceive_completed_cb callback,
329 data_h rawdata = NULL;
331 CHECK_SUPPORTED(NFC_TAG_FEATURE);
333 /* LCOV_EXCL_START */
335 CHECK_INVALID(tag == NULL);
336 CHECK_INVALID(buffer == NULL);
337 CHECK_INVALID(buffer_size <= 0);
339 CHECK_APP_PERMISSION();
341 ret = net_nfc_create_data(&rawdata, buffer, buffer_size);
342 if (ret == NET_NFC_OK) {
343 net_nfc_target_handle_h handle = NULL;
345 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
346 if (ret == NET_NFC_OK) {
349 parameter = g_variant_new("(tt)",
352 if (parameter != NULL) {
353 ret = net_nfc_client_transceive_data(
356 _tag_transceive_data_cb,
358 if (ret != NET_NFC_OK)
359 g_variant_unref(parameter);
361 ret = NET_NFC_ALLOC_FAIL;
364 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
367 net_nfc_free_data(rawdata);
369 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
372 return nfc_common_convert_error_code(__func__, ret);
376 int nfc_tag_get_type(nfc_tag_h tag, nfc_tag_type_e *type)
382 CHECK_SUPPORTED(NFC_TAG_FEATURE);
384 /* LCOV_EXCL_START */
386 CHECK_INVALID(tag == NULL);
387 CHECK_INVALID(type == NULL);
389 ret = net_nfc_get_tag_type(tag, (net_nfc_target_type_e *)type);
391 return nfc_common_convert_error_code(__func__, ret);
395 int nfc_tag_is_support_ndef(nfc_tag_h tag, bool *is_support)
401 CHECK_SUPPORTED(NFC_TAG_FEATURE);
403 /* LCOV_EXCL_START */
405 CHECK_INVALID(tag == NULL);
406 CHECK_INVALID(is_support == NULL);
408 ret = net_nfc_get_tag_ndef_support(tag, is_support);
410 return nfc_common_convert_error_code(__func__, ret);
414 int nfc_tag_get_maximum_ndef_size(nfc_tag_h tag, unsigned int *max_size)
419 CHECK_SUPPORTED(NFC_TAG_FEATURE);
421 /* LCOV_EXCL_START */
423 CHECK_INVALID(tag == NULL);
424 CHECK_INVALID(max_size == NULL);
426 ret = net_nfc_get_tag_max_data_size(tag, max_size);
428 return nfc_common_convert_error_code(__func__, ret);
432 int nfc_tag_get_ndef_size(nfc_tag_h tag, unsigned int *actual_data_size)
438 CHECK_SUPPORTED(NFC_TAG_FEATURE);
440 /* LCOV_EXCL_START */
442 CHECK_INVALID(tag == NULL);
443 CHECK_INVALID(actual_data_size == NULL);
445 ret = net_nfc_get_tag_actual_data_size(tag, actual_data_size);
447 return nfc_common_convert_error_code(__func__, ret);
451 int nfc_tag_foreach_information(nfc_tag_h tag,
452 nfc_tag_information_cb callback,
463 CHECK_SUPPORTED(NFC_TAG_FEATURE);
465 /* LCOV_EXCL_START */
467 CHECK_INVALID(tag == NULL);
468 CHECK_INVALID(callback == NULL);
470 ret = net_nfc_get_tag_info_keys((net_nfc_target_info_h)tag,
473 if (ret != NET_NFC_OK)
474 return nfc_common_convert_error_code(__func__, ret);
476 for (i = 0; i < count; i++) {
477 net_nfc_get_tag_info_value((net_nfc_target_info_h)tag, keys[i],
480 cont = callback(keys[i],
481 net_nfc_get_data_buffer(value),
482 net_nfc_get_data_length(value),
489 return NFC_ERROR_NONE;
494 /* LCOV_EXCL_START */
495 static void _mifare_authenticate_with_keyA_cb(net_nfc_error_e result,
498 nfc_mifare_authenticate_with_keyA_completed_cb callback;
503 if (user_data == NULL) {
504 LOG_ERR("user_data is NULL");
508 g_variant_get((GVariant *)user_data,
513 if (callback != NULL)
514 callback(nfc_common_convert_error_code(__func__, result), user_param);
516 g_variant_unref((GVariant *)user_data);
520 int nfc_mifare_authenticate_with_keyA(nfc_tag_h tag,
522 unsigned char *auth_key,
523 nfc_mifare_authenticate_with_keyA_completed_cb callback,
527 data_h auth_key_data = NULL;
529 CHECK_SUPPORTED(NFC_TAG_FEATURE);
531 /* LCOV_EXCL_START */
533 CHECK_INVALID(tag == NULL);
534 CHECK_INVALID(auth_key == NULL);
537 ret = net_nfc_create_data(&auth_key_data, auth_key, 6);
538 if (ret == NET_NFC_OK) {
539 net_nfc_target_handle_h handle = NULL;
541 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
542 if (ret == NET_NFC_OK) {
545 parameter = g_variant_new("(tt)",
548 if (parameter != NULL) {
549 ret = net_nfc_client_mifare_authenticate_with_keyA(
553 _mifare_authenticate_with_keyA_cb,
555 if (ret != NET_NFC_OK)
556 g_variant_unref(parameter);
558 ret = NET_NFC_ALLOC_FAIL;
561 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
564 net_nfc_free_data(auth_key_data);
566 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
569 return nfc_common_convert_error_code(__func__, ret);
574 /* LCOV_EXCL_START */
575 static void _mifare_authenticate_with_keyB_cb(net_nfc_error_e result,
578 nfc_mifare_authenticate_with_keyB_completed_cb callback;
581 if (user_data == NULL) {
582 LOG_ERR("user_data is NULL");
586 g_variant_get((GVariant *)user_data,
591 if (callback != NULL)
592 callback(nfc_common_convert_error_code(__func__, result), user_param);
594 g_variant_unref((GVariant *)user_data);
598 int nfc_mifare_authenticate_with_keyB(nfc_tag_h tag,
600 unsigned char *auth_key,
601 nfc_mifare_authenticate_with_keyB_completed_cb callback,
605 data_h auth_key_data = NULL;
609 CHECK_SUPPORTED(NFC_TAG_FEATURE);
611 /* LCOV_EXCL_START */
613 CHECK_INVALID(tag == NULL);
614 CHECK_INVALID(auth_key == NULL);
617 ret = net_nfc_create_data(&auth_key_data, auth_key, 6);
618 if (ret == NET_NFC_OK) {
619 net_nfc_target_handle_h handle = NULL;
621 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
622 if (ret == NET_NFC_OK) {
625 parameter = g_variant_new("(tt)",
628 if (parameter != NULL) {
629 ret = net_nfc_client_mifare_authenticate_with_keyB(
633 _mifare_authenticate_with_keyB_cb,
635 if (ret != NET_NFC_OK)
636 g_variant_unref(parameter);
638 ret = NET_NFC_ALLOC_FAIL;
641 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
644 net_nfc_free_data(auth_key_data);
646 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
649 return nfc_common_convert_error_code(__func__, ret);
654 /* LCOV_EXCL_START */
655 static void _mifare_read_block_cb(net_nfc_error_e result, data_h data,
658 nfc_mifare_read_block_completed_cb callback;
661 if (user_data == NULL) {
662 LOG_ERR("user_data is NULL");
666 g_variant_get((GVariant *)user_data,
671 if (callback != NULL) {
672 uint8_t *buffer = NULL;
675 if (result == NET_NFC_OK && data != NULL) {
676 buffer = net_nfc_get_data_buffer(data);
677 length = net_nfc_get_data_length(data);
680 callback(nfc_common_convert_error_code(__func__, result),
686 g_variant_unref((GVariant *)user_data);
690 int nfc_mifare_read_block(nfc_tag_h tag,
692 nfc_mifare_read_block_completed_cb callback,
696 net_nfc_target_handle_h handle = NULL;
700 CHECK_SUPPORTED(NFC_TAG_FEATURE);
702 /* LCOV_EXCL_START */
704 CHECK_INVALID(tag == NULL);
706 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
707 if (ret == NET_NFC_OK) {
710 parameter = g_variant_new("(tt)",
713 if (parameter != NULL) {
714 ret = net_nfc_client_mifare_read(
717 _mifare_read_block_cb,
719 if (ret != NET_NFC_OK)
720 g_variant_unref(parameter);
722 ret = NET_NFC_ALLOC_FAIL;
725 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
728 return nfc_common_convert_error_code(__func__, ret);
732 int nfc_mifare_read_page(nfc_tag_h tag,
734 nfc_mifare_read_page_completed_cb callback,
742 CHECK_SUPPORTED(NFC_TAG_FEATURE);
744 /* LCOV_EXCL_START */
746 CHECK_INVALID(tag == NULL);
748 parameter = g_variant_new("(tt)",
751 if (parameter != NULL) {
752 g_variant_unref(parameter);
755 ret = NET_NFC_ALLOC_FAIL;
758 return nfc_common_convert_error_code(__func__, ret);
762 /* LCOV_EXCL_START */
763 static void _mifare_write_block_cb(net_nfc_error_e result, void *user_data)
765 nfc_mifare_write_block_completed_cb callback;
770 if (user_data == NULL) {
771 LOG_ERR("user_data is NULL");
775 g_variant_get((GVariant *)user_data,
780 if (callback != NULL)
781 callback(nfc_common_convert_error_code(__func__, result), user_param);
783 g_variant_unref((GVariant *)user_data);
787 int nfc_mifare_write_block(nfc_tag_h tag,
789 unsigned char *buffer,
791 nfc_mifare_write_block_completed_cb callback,
795 data_h block_data = NULL;
799 CHECK_SUPPORTED(NFC_TAG_FEATURE);
801 /* LCOV_EXCL_START */
803 CHECK_INVALID(tag == NULL);
804 CHECK_INVALID(buffer == NULL);
805 CHECK_INVALID(buffer_size <= 0);
808 ret = net_nfc_create_data(&block_data, buffer, buffer_size);
809 if (ret == NET_NFC_OK) {
810 net_nfc_target_handle_h handle = NULL;
812 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
814 if (ret == NET_NFC_OK) {
817 parameter = g_variant_new("(tt)",
820 if (parameter != NULL) {
821 ret = net_nfc_client_mifare_write_block(
825 _mifare_write_block_cb,
827 if (ret != NET_NFC_OK)
828 g_variant_unref(parameter);
830 ret = NET_NFC_ALLOC_FAIL;
833 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
836 net_nfc_free_data(block_data);
838 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
841 return nfc_common_convert_error_code(__func__, ret);
845 /* LCOV_EXCL_START */
846 static void _mifare_write_page_cb(net_nfc_error_e result, void *user_data)
848 nfc_mifare_write_page_completed_cb callback;
853 if (user_data == NULL) {
854 LOG_ERR("user_data is NULL");
858 g_variant_get((GVariant *)user_data,
863 if (callback != NULL)
864 callback(nfc_common_convert_error_code(__func__, result), user_param);
866 g_variant_unref((GVariant *)user_data);
870 int nfc_mifare_write_page(nfc_tag_h tag,
872 unsigned char *buffer,
874 nfc_mifare_write_page_completed_cb callback,
878 data_h block_data = NULL;
881 CHECK_SUPPORTED(NFC_TAG_FEATURE);
883 /* LCOV_EXCL_START */
885 CHECK_INVALID(tag == NULL);
886 CHECK_INVALID(buffer == NULL);
887 CHECK_INVALID(buffer_size <= 0);
890 ret = net_nfc_create_data(&block_data, buffer, buffer_size);
891 if (ret == NET_NFC_OK) {
892 net_nfc_target_handle_h handle = NULL;
894 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag,
896 if (ret == NET_NFC_OK) {
899 parameter = g_variant_new("(tt)",
902 if (parameter != NULL) {
903 ret = net_nfc_client_mifare_write_page(
907 _mifare_write_page_cb,
909 if (ret != NET_NFC_OK)
910 g_variant_unref(parameter);
912 ret = NET_NFC_ALLOC_FAIL;
915 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
918 net_nfc_free_data(block_data);
920 LOG_ERR("net_nfc_create_data failed, [%d]", ret);
923 return nfc_common_convert_error_code(__func__, ret);
927 /* LCOV_EXCL_START */
928 static void _mifare_increment_cb(net_nfc_error_e result, void *user_data)
930 nfc_mifare_increment_completed_cb callback;
935 if (user_data == NULL) {
936 LOG_ERR("user_data is NULL");
940 g_variant_get((GVariant *)user_data,
945 if (callback != NULL)
946 callback(nfc_common_convert_error_code(__func__, result), user_param);
948 g_variant_unref((GVariant *)user_data);
952 int nfc_mifare_increment(nfc_tag_h tag,
955 nfc_mifare_increment_completed_cb callback,
959 net_nfc_target_handle_h handle = NULL;
963 CHECK_SUPPORTED(NFC_TAG_FEATURE);
965 /* LCOV_EXCL_START */
967 CHECK_INVALID(tag == NULL);
970 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
971 if (ret == NET_NFC_OK) {
974 parameter = g_variant_new("(tt)",
977 if (parameter != NULL) {
978 ret = net_nfc_client_mifare_increment(
982 _mifare_increment_cb,
984 if (ret != NET_NFC_OK)
985 g_variant_unref(parameter);
987 ret = NET_NFC_ALLOC_FAIL;
990 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
993 return nfc_common_convert_error_code(__func__, ret);
997 /* LCOV_EXCL_START */
998 static void _mifare_decrement_cb(net_nfc_error_e result, void *user_data)
1000 nfc_mifare_decrement_completed_cb callback;
1005 if (user_data == NULL) {
1006 LOG_ERR("user_data is NULL");
1010 g_variant_get((GVariant *)user_data,
1015 if (callback != NULL)
1016 callback(nfc_common_convert_error_code(__func__, result), user_param);
1018 g_variant_unref((GVariant *)user_data);
1020 /* LCOV_EXCL_STOP */
1022 int nfc_mifare_decrement(nfc_tag_h tag,
1025 nfc_mifare_decrement_completed_cb callback,
1029 net_nfc_target_handle_h handle = NULL;
1033 CHECK_SUPPORTED(NFC_TAG_FEATURE);
1035 /* LCOV_EXCL_START */
1037 CHECK_INVALID(tag == NULL);
1040 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
1041 if (ret == NET_NFC_OK) {
1042 GVariant *parameter;
1044 parameter = g_variant_new("(tt)",
1047 if (parameter != NULL) {
1048 ret = net_nfc_client_mifare_decrement(
1052 _mifare_decrement_cb,
1054 if (ret != NET_NFC_OK)
1055 g_variant_unref(parameter);
1057 ret = NET_NFC_ALLOC_FAIL;
1060 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
1063 return nfc_common_convert_error_code(__func__, ret);
1064 /* LCOV_EXCL_STOP */
1067 /* LCOV_EXCL_START */
1068 static void _mifare_transfer_cb(net_nfc_error_e result, void *user_data)
1070 nfc_mifare_transfer_completed_cb callback;
1075 if (user_data == NULL) {
1076 LOG_ERR("user_data is NULL");
1080 g_variant_get((GVariant *)user_data,
1085 if (callback != NULL)
1086 callback(nfc_common_convert_error_code(__func__, result), user_param);
1088 g_variant_unref((GVariant *)user_data);
1090 /* LCOV_EXCL_STOP */
1092 int nfc_mifare_transfer(nfc_tag_h tag,
1094 nfc_mifare_transfer_completed_cb callback,
1098 net_nfc_target_handle_h handle = NULL;
1102 CHECK_SUPPORTED(NFC_TAG_FEATURE);
1104 /* LCOV_EXCL_START */
1106 CHECK_INVALID(tag == NULL);
1109 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
1110 if (ret == NET_NFC_OK) {
1111 GVariant *parameter;
1113 parameter = g_variant_new("(tt)",
1116 if (parameter != NULL) {
1117 ret = net_nfc_client_mifare_transfer(
1120 _mifare_transfer_cb,
1122 if (ret != NET_NFC_OK)
1123 g_variant_unref(parameter);
1125 ret = NET_NFC_ALLOC_FAIL;
1128 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
1131 return nfc_common_convert_error_code(__func__, ret);
1132 /* LCOV_EXCL_STOP */
1135 /* LCOV_EXCL_START */
1136 static void _mifare_restore_cb(net_nfc_error_e result, void *user_data)
1138 nfc_mifare_restore_completed_cb callback;
1143 if (user_data == NULL) {
1144 LOG_ERR("user_data is NULL");
1148 g_variant_get((GVariant *)user_data,
1153 if (callback != NULL)
1154 callback(nfc_common_convert_error_code(__func__, result), user_param);
1156 g_variant_unref((GVariant *)user_data);
1158 /* LCOV_EXCL_STOP */
1160 int nfc_mifare_restore(nfc_tag_h tag,
1162 nfc_mifare_restore_completed_cb callback,
1166 net_nfc_target_handle_h handle = NULL;
1170 CHECK_SUPPORTED(NFC_TAG_FEATURE);
1172 /* LCOV_EXCL_START */
1174 CHECK_INVALID(tag == NULL);
1177 ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
1178 if (ret == NET_NFC_OK) {
1179 GVariant *parameter;
1181 parameter = g_variant_new("(tt)",
1184 if (parameter != NULL) {
1185 ret = net_nfc_client_mifare_restore(
1190 if (ret != NET_NFC_OK)
1191 g_variant_unref(parameter);
1193 ret = NET_NFC_ALLOC_FAIL;
1196 LOG_ERR("net_nfc_get_tag_handle failed, [%d]", ret);
1199 return nfc_common_convert_error_code(__func__, ret);
1200 /* LCOV_EXCL_STOP */
1203 int nfc_barcode_get_barcode(unsigned char **barcode, int *barcode_len)
1209 CHECK_SUPPORTED(NFC_TAG_FEATURE);
1211 /* LCOV_EXCL_START */
1213 CHECK_INVALID(barcode == NULL);
1214 CHECK_INVALID(barcode_len == NULL);
1218 ret = net_nfc_client_barcode_get_barcode_sync(barcode, barcode_len);
1220 return nfc_common_convert_error_code(__func__, ret);
1221 /* LCOV_EXCL_STOP */