typedef void (*net_nfc_p2p_connection_handover_completed_cb)(
net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e carrier,
- data_h ac_data,
+ net_nfc_data_h ac_data,
void *user_data);
typedef void (*net_nfc_connection_handover_event_cb)(
net_nfc_handover_event_e event,
net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e carrier,
- data_h ac_data,
- data_h ndef_message,
+ net_nfc_data_h ac_data,
+ net_nfc_data_h ndef_message,
void *user_data);
net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_data(
net_nfc_connection_handover_info_h info_handle,
- data_h *data);
+ net_nfc_data_h *data);
net_nfc_error_e net_nfc_client_p2p_connection_handover(
net_nfc_target_handle_h handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_conn_handover_carrier_type_e *out_carrier,
- data_h *out_ac_data);
+ net_nfc_data_h *out_ac_data);
void net_nfc_client_handover_set_handover_event_cb(
typedef void (*net_nfc_client_hce_event_cb)(
net_nfc_target_handle_h handle,
net_nfc_hce_event_t event,
- data_h apdu,
+ net_nfc_data_h apdu,
void *user_data);
/************* Hce API's*************/
net_nfc_error_e net_nfc_client_hce_unset_event_received_cb(void);
net_nfc_error_e net_nfc_client_hce_response_apdu_sync(
- net_nfc_target_handle_h handle, data_h resp_apdu_data);
+ net_nfc_target_handle_h handle, net_nfc_data_h resp_apdu_data);
/* internal */
void net_nfc_client_hce_deinit(void);
void net_nfc_client_hce_process_received_event(int event,
- net_nfc_target_handle_h handle, data_h data);
+ net_nfc_target_handle_h handle, net_nfc_data_h data);
#ifdef __cplusplus
}
bool net_nfc_client_hce_ipc_is_initialized();
bool net_nfc_server_hce_ipc_send_to_server(int type,
- net_nfc_target_handle_s *handle, data_s *data);
+ net_nfc_target_handle_s *handle, net_nfc_data_s *data);
#ifdef __cplusplus
}
void *user_data);
typedef void (*net_nfc_client_llcp_receive_completed)(net_nfc_error_e result,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
typedef void (*net_nfc_client_llcp_receive_from_completed)(
net_nfc_error_e result,
sap_t sap,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
typedef void (*net_nfc_client_llcp_close_completed)(net_nfc_error_e result,
net_nfc_llcp_socket_t *out_socket);
net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_llcp_send_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
- data_h data);
+ net_nfc_data_h data);
net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_llcp_send_to_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data);
+ net_nfc_data_h data);
net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
size_t request_length,
net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
size_t request_length,
- data_h *out_data);
+ net_nfc_data_h *out_data);
net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
size_t request_length,
net_nfc_llcp_socket_t socket,
size_t request_length,
sap_t *out_sap,
- data_h *out_data);
+ net_nfc_data_h *out_data);
net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
net_nfc_client_llcp_close_completed callback,
net_nfc_target_handle_h handle);
net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
- data_h key,
+ net_nfc_data_h key,
net_nfc_client_ndef_format_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_ndef_format_sync(
net_nfc_target_handle_h handle,
- data_h key);
+ net_nfc_data_h key);
/* TODO : move to internal header */
net_nfc_error_e net_nfc_client_ndef_init(void);
typedef void (*net_nfc_client_p2p_device_detached)(void *user_data);
-typedef void (*net_nfc_client_p2p_data_received)(data_h p2p_data,
+typedef void (*net_nfc_client_p2p_data_received)(net_nfc_data_h p2p_data,
void *user_data);
/* P2P client API's*/
net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_h handle,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_p2p_send_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_h handle,
- data_h data);
+ net_nfc_data_h data);
/* P2P client API's - used for registering callbacks*/
typedef void (*net_nfc_se_get_atr_cb)(
net_nfc_error_e result,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
typedef void (*net_nfc_se_send_apdu_cb)(
net_nfc_error_e result,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
typedef void (*net_nfc_client_se_event)(
typedef void (*net_nfc_client_se_transaction_event)(
net_nfc_se_type_e se_type,
- data_h aid,
- data_h param,
+ net_nfc_data_h aid,
+ net_nfc_data_h param,
void *user_data);
typedef void (*net_nfc_client_se_ese_detected_event)(
net_nfc_target_handle_h handle,
int dev_type,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
typedef bool (*net_nfc_client_se_registered_aid_cb)(net_nfc_se_type_e se_type,
net_nfc_error_e net_nfc_client_se_get_atr_sync(
nfc_se_h handle,
- data_h *atr);
+ net_nfc_data_h *atr);
net_nfc_error_e net_nfc_client_se_send_apdu(
nfc_se_h handle,
- data_h apdu_data,
+ net_nfc_data_h apdu_data,
net_nfc_se_send_apdu_cb callback,
void *user_data);
net_nfc_error_e net_nfc_client_se_send_apdu_sync(
nfc_se_h handle,
- data_h apdu_data,
- data_h *response);
+ net_nfc_data_h apdu_data,
+ net_nfc_data_h *response);
/************* Secure Element CallBack Register/Deregister functions*************/
net_nfc_error_e net_nfc_client_se_set_preferred_handler_sync(bool state);
-/*net_nfc_error_e net_nfc_client_hce_get_route_table_sync(data_h arg_aid);*/
+/*net_nfc_error_e net_nfc_client_hce_get_route_table_sync(net_nfc_data_h arg_aid);*/
/* TODO : move to internal header */
uint16_t service_list[],
uint8_t number_of_blocks,
uint8_t block_list[],
- data_h data,
+ net_nfc_data_h data,
nfc_transceive_data_callback callback,
void *user_data);
net_nfc_error_e net_nfc_get_target_info_from_device_type(net_nfc_target_handle_h handle, net_nfc_target_type_e device_type, net_nfc_target_info_s** target_info);
-net_nfc_error_e net_nfc_get_tag_info_value_from_key(net_nfc_target_info_s* target_info, const char* key, int valid_length, data_h* data);
+net_nfc_error_e net_nfc_get_tag_info_value_from_key(net_nfc_target_info_s* target_info, const char* key, int valid_length, net_nfc_data_h* data);
#ifdef __cplusplus
}
net_nfc_error_e net_nfc_client_test_set_ee_data(int mode,
int reg_id,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_test_set_ee_data_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_test_set_ee_data_sync(int mode,
int reg_id,
- data_h data);
+ net_nfc_data_h data);
net_nfc_error_e net_nfc_client_test_ese_test(
net_nfc_client_test_sim_test_completed callback,
void *user_data);
typedef void (*nfc_transceive_data_callback)(net_nfc_error_e result,
- data_h data,
+ net_nfc_data_h data,
void *user_data);
net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_h handle,
- data_h rawdata,
+ net_nfc_data_h rawdata,
nfc_transceive_callback callback,
void *user_data);
net_nfc_error_e net_nfc_client_transceive_data(net_nfc_target_handle_h handle,
- data_h rawdata,
+ net_nfc_data_h rawdata,
nfc_transceive_data_callback callback,
void *user_data);
net_nfc_error_e net_nfc_client_transceive_sync(net_nfc_target_handle_h handle,
- data_h rawdata);
+ net_nfc_data_h rawdata);
net_nfc_error_e net_nfc_client_transceive_data_sync(
net_nfc_target_handle_h handle,
- data_h rawdata,
- data_h *response);
+ net_nfc_data_h rawdata,
+ net_nfc_data_h *response);
/* TODO : move to internal header */
net_nfc_error_e net_nfc_client_transceive_init(void);
@exception NET_NFC_ALLOC_FAIL memory allocation is failed
*/
-net_nfc_error_e net_nfc_create_data_only(data_h *data);
+net_nfc_error_e net_nfc_create_data_only(net_nfc_data_h *data);
/**
create data handler with initial values, bytes will be copied into the data handler.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
@exception NET_NFC_ALLOC_FAIL memory allocation is failed
*/
-net_nfc_error_e net_nfc_create_data(data_h *data, const uint8_t *bytes, size_t length);
+net_nfc_error_e net_nfc_create_data(net_nfc_data_h *data, const uint8_t *bytes, size_t length);
/**
get the byes and length from data handler. data handler assume bytes may have '0x0' value.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_data(const data_h data, uint8_t **bytes, size_t *length);
+net_nfc_error_e net_nfc_get_data(const net_nfc_data_h data, uint8_t **bytes, size_t *length);
/**
replace the data handler with given bytes. binary data (bytes) will be copied to data hander.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_set_data(data_h data, const uint8_t *bytes, size_t length);
+net_nfc_error_e net_nfc_set_data(net_nfc_data_h data, const uint8_t *bytes, size_t length);
/**
get length of data handler's bytes.
@exception 0 is returned if data is NULL
*/
-size_t net_nfc_get_data_length(const data_h data);
+size_t net_nfc_get_data_length(const net_nfc_data_h data);
/**
get pointer of the handler's bytes (do not free this. it should be freed when the application call "net_nfc_free_data" function)
@exception NULL is returned if data is NULL
*/
-uint8_t *net_nfc_get_data_buffer(const data_h data);
+uint8_t *net_nfc_get_data_buffer(const net_nfc_data_h data);
/**
free data handler. (it also free the copied bytes)
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_free_data(data_h data);
+net_nfc_error_e net_nfc_free_data(net_nfc_data_h data);
/**
@code
net_nfc_error_e result = NET_NFC_OK;
- data_h rawdata;
+ net_nfc_data_h rawdata;
ndef_message_h msg = NULL;
ndef_record_h record = NULL;
int idx;
*/
-net_nfc_error_e net_nfc_create_rawdata_from_ndef_message(ndef_message_h ndef_message, data_h *rawdata);
+net_nfc_error_e net_nfc_create_rawdata_from_ndef_message(ndef_message_h ndef_message, net_nfc_data_h *rawdata);
/**
This function return the structure of ndef_message from serial format of ndef message.
{
record_h record;
ndef_message_h url;
- data_h ndef_type;
- data_h payload;
+ net_nfc_data_h ndef_type;
+ net_nfc_data_h payload;
ndef_message_h ndef = (ndef_message_h)(data);
net_nfc_get_record_by_index (ndef, 0, &record);
*/
-net_nfc_error_e net_nfc_create_ndef_message_from_rawdata(ndef_message_h *ndef_message, data_h rawdata);
+net_nfc_error_e net_nfc_create_ndef_message_from_rawdata(ndef_message_h *ndef_message, net_nfc_data_h rawdata);
/**
it returns the total size of ndef message bytes. parse the structure data and count the bytes
@code
net_nfc_error_e result = NET_NFC_OK;
- data_h rawdata;
+ net_nfc_data_h rawdata;
ndef_message_h msg = NULL;
ndef_record_h record = NULL;
int idx;
@endcode
*/
-net_nfc_error_e net_nfc_search_record_by_type(ndef_message_h ndef_message, net_nfc_record_tnf_e tnf, data_h type, ndef_record_h *record);
+net_nfc_error_e net_nfc_search_record_by_type(ndef_message_h ndef_message, net_nfc_record_tnf_e tnf, net_nfc_data_h type, ndef_record_h *record);
/**
char uri[] = " yahoo.com";
ndef_record_s uriRecord;
- data_h payload;
+ net_nfc_data_h payload;
net_nfc_create_data (&payload, uri, strlen (uri));
uri[0] = 0x01;
}
@endcode
*/
-net_nfc_error_e net_nfc_create_record(ndef_record_h *record, net_nfc_record_tnf_e tnf, data_h typeName, data_h id, data_h payload);
+net_nfc_error_e net_nfc_create_record(ndef_record_h *record, net_nfc_record_tnf_e tnf, net_nfc_data_h typeName, net_nfc_data_h id, net_nfc_data_h payload);
/**
Do not free the payload. it will be freed when the record is freed
@param[in] record Record handler
- @param[out] payload data_h type payload pointer (it gives you the pointer of payload; not copied)
+ @param[out] payload net_nfc_data_h type payload pointer (it gives you the pointer of payload; not copied)
@return return the result of the calling the function
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record, data_h *payload);
+net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record, net_nfc_data_h *payload);
/**
this function is getter of record type.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, data_h *type);
+net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, net_nfc_data_h *type);
/**
this function is getter of record ID.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, data_h *id);
+net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, net_nfc_data_h *id);
/**
this function is getter of record TNF value.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, data_h id);
+net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, net_nfc_data_h id);
/**
this function free the record handler. do not use this function after appending the ndef message
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyA(
net_nfc_target_handle_h handle,
uint8_t sector,
- data_h auth_key,
+ net_nfc_data_h auth_key,
void *callback,
void *user_data);
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyB(
net_nfc_target_handle_h handle,
uint8_t sector,
- data_h auth_key,
+ net_nfc_data_h auth_key,
void *callback,
void *user_data);
net_nfc_error_e net_nfc_client_mifare_write_block(
net_nfc_target_handle_h handle,
uint8_t addr,
- data_h data,
+ net_nfc_data_h data,
void *callback,
void *user_data);
net_nfc_error_e net_nfc_client_mifare_write_page(
net_nfc_target_handle_h handle,
uint8_t addr,
- data_h data,
+ net_nfc_data_h data,
void *callback,
void *user_data);
*/
-net_nfc_error_e net_nfc_client_mifare_create_default_key(data_h* key);
+net_nfc_error_e net_nfc_client_mifare_create_default_key(net_nfc_data_h* key);
/**
create mifare application directory key. The key is 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5
*/
net_nfc_error_e net_nfc_client_mifare_create_application_directory_key(
- data_h* key);
+ net_nfc_data_h* key);
/**
create nfc forum key. The key is 0xD3, 0xF7, 0xD3, 0xF7, 0xD3, 0xF7
*/
-net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(data_h* key);
+net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(net_nfc_data_h* key);
/**
@} */
for(; index < keys_length; index++)
{
char* key = keys[index];
- data_h value;
+ net_nfc_data_h value;
net_nfc_get_tag_info_value(target_info, key, &value);
net_nfc_free_data(value);
}
@exception NET_NFC_NO_DATA_FOUND No data is returned
*/
-net_nfc_error_e net_nfc_get_tag_info_value(net_nfc_target_info_h target_info, const char *key, data_h *value);
+net_nfc_error_e net_nfc_get_tag_info_value(net_nfc_target_info_h target_info, const char *key, net_nfc_data_h *value);
/**
Get ndef message of current tag
extern _nfc_context_s gdbus_nfc_context;
pid_t nfc_common_get_focus_app_pid();
-char * nfc_common_get_bt_address_string(data_h data);
+char * nfc_common_get_bt_address_string(net_nfc_data_h data);
bool nfc_common_check_app_permission();
int nfc_common_convert_error_code(const char *func, int native_error_code);
bool nfc_common_is_initialized();
/* LCOV_EXCL_START */
-NET_NFC_EXPORT_API net_nfc_error_e net_nfc_create_data_only(data_h *data)
+NET_NFC_EXPORT_API net_nfc_error_e net_nfc_create_data_only(net_nfc_data_h *data)
{
return net_nfc_create_data(data, NULL, 0);
}
-NET_NFC_EXPORT_API net_nfc_error_e net_nfc_create_data(data_h *data,
+NET_NFC_EXPORT_API net_nfc_error_e net_nfc_create_data(net_nfc_data_h *data,
const uint8_t *bytes, size_t length)
{
- data_s *tmp_data = NULL;
+ net_nfc_data_s *tmp_data = NULL;
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
if (length > 0 && bytes != NULL)
memcpy(tmp_data->buffer, bytes, length);
- *data = (data_h)tmp_data;
+ *data = (net_nfc_data_h)tmp_data;
return NET_NFC_OK;
}
-NET_NFC_EXPORT_API net_nfc_error_e net_nfc_get_data(const data_h data,
+NET_NFC_EXPORT_API net_nfc_error_e net_nfc_get_data(const net_nfc_data_h data,
uint8_t **bytes, size_t *length)
{
- data_s *tmp_data = (data_s *)data;
+ net_nfc_data_s *tmp_data = (net_nfc_data_s *)data;
if (bytes == NULL || length == NULL)
return NET_NFC_NULL_PARAMETER;
return NET_NFC_OK;
}
-NET_NFC_EXPORT_API net_nfc_error_e net_nfc_set_data(data_h data,
+NET_NFC_EXPORT_API net_nfc_error_e net_nfc_set_data(net_nfc_data_h data,
const uint8_t *bytes, size_t length)
{
- data_s *tmp_data = (data_s *)data;
+ net_nfc_data_s *tmp_data = (net_nfc_data_s *)data;
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
return NET_NFC_OK;
}
-NET_NFC_EXPORT_API size_t net_nfc_get_data_length(const data_h data)
+NET_NFC_EXPORT_API size_t net_nfc_get_data_length(const net_nfc_data_h data)
{
- data_s *tmp_data = (data_s *)data;
+ net_nfc_data_s *tmp_data = (net_nfc_data_s *)data;
if (data == NULL)
return 0;
return tmp_data->length;
}
-NET_NFC_EXPORT_API uint8_t *net_nfc_get_data_buffer(const data_h data)
+NET_NFC_EXPORT_API uint8_t *net_nfc_get_data_buffer(const net_nfc_data_h data)
{
- data_s *tmp_data = (data_s *)data;
+ net_nfc_data_s *tmp_data = (net_nfc_data_s *)data;
if (data == NULL)
return NULL;
return tmp_data->buffer;
}
-NET_NFC_EXPORT_API net_nfc_error_e net_nfc_free_data(data_h data)
+NET_NFC_EXPORT_API net_nfc_error_e net_nfc_free_data(net_nfc_data_h data)
{
- data_s *tmp_data = (data_s *)data;
+ net_nfc_data_s *tmp_data = (net_nfc_data_s *)data;
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
static void __started(NetNfcGDbusHandover *object,
GVariant *arg_message)
{
- data_s message;
+ net_nfc_data_s message;
INFO_MSG(">>> SIGNAL arrived");
- net_nfc_util_gdbus_variant_to_data_s(arg_message, &message);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_message, &message);
if (handover_callbacks.handover_event_cb != NULL) {
handover_callbacks.handover_event_cb(NET_NFC_HANDOVER_START,
GVariant *arg_address,
GVariant *arg_message)
{
- data_s address, message;
+ net_nfc_data_s address, message;
INFO_MSG(">>> SIGNAL arrived");
- net_nfc_util_gdbus_variant_to_data_s(arg_address, &address);
- net_nfc_util_gdbus_variant_to_data_s(arg_message, &message);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_address, &address);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_message, &message);
if (handover_callbacks.handover_event_cb != NULL) {
handover_callbacks.handover_event_cb(NET_NFC_HANDOVER_FINISH,
net_nfc_conn_handover_carrier_type_e type =
NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
GError *error = NULL;
- data_s arg_data;
+ net_nfc_data_s arg_data;
g_assert(user_data != NULL);
net_nfc_p2p_connection_handover_completed_cb callback =
(net_nfc_p2p_connection_handover_completed_cb)func_data->callback;
- net_nfc_util_gdbus_variant_to_data_s(data, &arg_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(data, &arg_data);
callback(result,
type,
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_data(
net_nfc_connection_handover_info_h info_handle,
- data_h *data)
+ net_nfc_data_h *data)
{
net_nfc_connection_handover_info_s *info =
(net_nfc_connection_handover_info_s *)info_handle;
net_nfc_target_handle_h handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_conn_handover_carrier_type_e *out_carrier,
- data_h *out_ac_data)
+ net_nfc_data_h *out_ac_data)
{
net_nfc_target_handle_s *tag_handle = (net_nfc_target_handle_s *)handle;
GVariant *out_data = NULL;
if (hce_handler.hce_event_cb != NULL) {
- data_s apdu = { NULL, 0 };
+ net_nfc_data_s apdu = { NULL, 0 };
- net_nfc_util_gdbus_variant_to_data_s(arg_apdu, &apdu);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_apdu, &apdu);
hce_handler.hce_event_cb((net_nfc_target_handle_h)GUINT_TO_POINTER(arg_handle),
(net_nfc_hce_event_t)arg_event, &apdu,
}
void net_nfc_client_hce_process_received_event(int event,
- net_nfc_target_handle_h handle, data_h data)
+ net_nfc_target_handle_h handle, net_nfc_data_h data)
{
INFO_MSG(">>> SIGNAL arrived");
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_hce_response_apdu_sync(
net_nfc_target_handle_h handle,
- data_h resp_apdu_data)
+ net_nfc_data_h resp_apdu_data)
{
net_nfc_error_e result = NET_NFC_OK;
GError *error = NULL;
}
}
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)resp_apdu_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)resp_apdu_data);
if (arg_data == NULL) {
INFO_MSG(">>> resp_apdu_data is null !!");
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_hce_response_apdu_sync(
net_nfc_target_handle_h handle,
- data_h resp_apdu_data)
+ net_nfc_data_h resp_apdu_data)
{
net_nfc_error_e result;
DEBUG_ERR_MSG("fcntl, executing nonblock error");
}
-static bool __receive_data_from_server(int socket, data_s *data)
+static bool __receive_data_from_server(int socket, net_nfc_data_s *data)
{
bool result;
ssize_t ret;
static bool __process_server_message()
{
bool result = false;
- data_s data;
+ net_nfc_data_s data;
if (__receive_data_from_server(hce_client_socket, &data) == true) {
net_nfc_hce_data_t *header;
- data_s temp;
+ net_nfc_data_s temp;
header = (net_nfc_hce_data_t *)data.buffer;
temp.length = data.length - sizeof(net_nfc_hce_data_t);
net_nfc_client_hce_process_received_event(header->type,
- (net_nfc_target_handle_h)GUINT_TO_POINTER(header->handle), (data_h)&temp);
+ (net_nfc_target_handle_h)GUINT_TO_POINTER(header->handle), (net_nfc_data_h)&temp);
result = true;
} else {
return result;
}
-static bool __send_data_to_server(int socket, data_s *data)
+static bool __send_data_to_server(int socket, net_nfc_data_s *data)
{
ssize_t ret;
}
bool net_nfc_server_hce_ipc_send_to_server(int type,
- net_nfc_target_handle_s *handle, data_s *data)
+ net_nfc_target_handle_s *handle, net_nfc_data_s *data)
{
bool ret = false;
- data_s temp;
+ net_nfc_data_s temp;
uint32_t len = sizeof(net_nfc_hce_data_t);
if (data != NULL && data->length > 0)
if (func_data->callback != NULL) {
net_nfc_client_llcp_receive_completed callback =
(net_nfc_client_llcp_receive_completed)func_data->callback;
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
- net_nfc_util_gdbus_variant_to_data_s(variant, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(variant, &data);
callback(result, &data, func_data->user_data);
if (func_data->callback != NULL) {
net_nfc_client_llcp_receive_from_completed callback =
(net_nfc_client_llcp_receive_from_completed)func_data->callback;
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
- net_nfc_util_gdbus_variant_to_data_s(variant, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(variant, &data);
callback(result, sap, &data, func_data->user_data);
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_llcp_send_completed callback,
void *user_data)
{
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
- data_h data)
+ net_nfc_data_h data)
{
net_nfc_error_e result;
GVariant *variant;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_llcp_send_to_completed callback,
void *user_data)
{
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data)
+ net_nfc_data_h data)
{
net_nfc_error_e result;
GVariant *variant;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
size_t request_length,
- data_h *out_data)
+ net_nfc_data_h *out_data)
{
net_nfc_error_e result;
GVariant *variant;
net_nfc_llcp_socket_t socket,
size_t request_length,
sap_t *out_sap,
- data_h *out_data)
+ net_nfc_data_h *out_data)
{
net_nfc_error_e result;
GError *error = NULL;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
- data_h key,
+ net_nfc_data_h key,
net_nfc_client_ndef_format_completed callback,
void *user_data)
{
func_data->callback = (gpointer)callback;
func_data->user_data = user_data;
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)key);
net_nfc_gdbus_ndef_call_format(ndef_proxy ,
GPOINTER_TO_UINT(handle),
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_ndef_format_sync(
net_nfc_target_handle_h handle,
- data_h key)
+ net_nfc_data_h key)
{
net_nfc_error_e out_result = NET_NFC_OK;
GVariant *arg_data;
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_NOT_CONNECTED;
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)key);
if (net_nfc_gdbus_ndef_call_format_sync(ndef_proxy ,
GPOINTER_TO_UINT(handle),
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_create_rawdata_from_ndef_message(
- ndef_message_h ndef_message, data_h *rawdata)
+ ndef_message_h ndef_message, net_nfc_data_h *rawdata)
{
uint32_t count;
net_nfc_error_e result;
- data_h data;
+ net_nfc_data_h data;
if (ndef_message == NULL || rawdata == NULL)
return NET_NFC_NULL_PARAMETER;
return result;
result = net_nfc_util_convert_ndef_message_to_rawdata(
- (ndef_message_s *)ndef_message, (data_s *)data);
+ (ndef_message_s *)ndef_message, (net_nfc_data_s *)data);
if (result == NET_NFC_OK)
*rawdata = data;
else
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_create_ndef_message_from_rawdata(
- ndef_message_h *ndef_message, data_h rawdata)
+ ndef_message_h *ndef_message, net_nfc_data_h rawdata)
{
net_nfc_error_e result = NET_NFC_OK;
ndef_message_h msg;
return result;
result = net_nfc_util_convert_rawdata_to_ndef_message(
- (data_s *)rawdata, (ndef_message_s *)msg);
+ (net_nfc_data_s *)rawdata, (ndef_message_s *)msg);
if (result == NET_NFC_OK)
*ndef_message = msg;
else
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_search_record_by_type(ndef_message_h ndef_message,
- net_nfc_record_tnf_e tnf, data_h type, ndef_record_h *record)
+ net_nfc_record_tnf_e tnf, net_nfc_data_h type, ndef_record_h *record)
{
return net_nfc_util_search_record_by_type(
(ndef_message_s *)ndef_message, tnf,
- (data_s *)type, (ndef_record_s **)record);
+ (net_nfc_data_s *)type, (ndef_record_s **)record);
}
NET_NFC_EXPORT_API
DEBUG_CLIENT_MSG("message length = [%ld]", size);
if (size > 0) {
- data_s data = { NULL, 0 };
+ net_nfc_data_s data = { NULL, 0 };
if (net_nfc_util_init_data(&data, size) == true) {
int current;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_create_record(ndef_record_h *record,
- net_nfc_record_tnf_e tnf, data_h typeName, data_h id, data_h payload)
+ net_nfc_record_tnf_e tnf, net_nfc_data_h typeName, net_nfc_data_h id, net_nfc_data_h payload)
{
- return net_nfc_util_create_record(tnf, (data_s *)typeName,
- (data_s *)id, (data_s *)payload, (ndef_record_s **)record);
+ return net_nfc_util_create_record(tnf, (net_nfc_data_s *)typeName,
+ (net_nfc_data_s *)id, (net_nfc_data_s *)payload, (ndef_record_s **)record);
}
NET_NFC_EXPORT_API
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record,
- data_h *payload)
+ net_nfc_data_h *payload)
{
ndef_record_s *struct_record = (ndef_record_s *)record;
if (record == NULL || payload == NULL)
return NET_NFC_NULL_PARAMETER;
- *payload = (data_h)&(struct_record->payload_s);
+ *payload = (net_nfc_data_h)&(struct_record->payload_s);
return NET_NFC_OK;
}
NET_NFC_EXPORT_API
-net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, data_h *type)
+net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, net_nfc_data_h *type)
{
ndef_record_s *struct_record = (ndef_record_s *)record;
if (record == NULL || type == NULL)
return NET_NFC_NULL_PARAMETER;
- *type = (data_h)&(struct_record->type_s);
+ *type = (net_nfc_data_h)&(struct_record->type_s);
return NET_NFC_OK;
}
NET_NFC_EXPORT_API
-net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, data_h *id)
+net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, net_nfc_data_h *id)
{
ndef_record_s *struct_record = (ndef_record_s *)record;
if (record == NULL || id == NULL)
return NET_NFC_NULL_PARAMETER;
- *id = (data_h)&(struct_record->id_s);
+ *id = (net_nfc_data_h)&(struct_record->id_s);
return NET_NFC_OK;
}
}
NET_NFC_EXPORT_API
-net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, data_h id)
+net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, net_nfc_data_h id)
{
- data_s *tmp_id = (data_s *)id;
+ net_nfc_data_s *tmp_id = (net_nfc_data_s *)id;
if (record == NULL || tmp_id == NULL)
return NET_NFC_NULL_PARAMETER;
static bool _is_text_record(ndef_record_h record)
{
bool result = false;
- data_h type;
+ net_nfc_data_h type;
if ((net_nfc_get_record_type(record, &type) == NET_NFC_OK) &&
(strncmp((char *)net_nfc_get_data_buffer(type),
ndef_record_h record, char **buffer)
{
net_nfc_error_e result;
- data_h payload;
+ net_nfc_data_h payload;
if (record == NULL || buffer == NULL)
return NET_NFC_NULL_PARAMETER;
ndef_record_h record, char **lang_code_str)
{
net_nfc_error_e result;
- data_h payload;
+ net_nfc_data_h payload;
if (record == NULL || lang_code_str == NULL)
return NET_NFC_NULL_PARAMETER;
net_nfc_encode_type_e *encoding)
{
net_nfc_error_e result;
- data_h payload;
+ net_nfc_data_h payload;
if (record == NULL || encoding == NULL)
return NET_NFC_NULL_PARAMETER;
INFO_MSG(">>> SIGNAL arrived");
if (p2p_signal_handler.p2p_data_received_cb) {
- data_s p2p_data = { NULL, };
+ net_nfc_data_s p2p_data = { NULL, };
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &p2p_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &p2p_data);
p2p_signal_handler.p2p_data_received_cb(&p2p_data,
p2p_signal_handler.p2p_data_received_data);
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_h handle,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_p2p_send_completed callback,
void *user_data)
{
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_h handle,
- data_h data)
+ net_nfc_data_h data)
{
GVariant *arg_data;
GError *error = NULL;
INFO_MSG(">>> SIGNAL arrived");
if (se_esedetecthandler.se_ese_detected_cb != NULL) {
- data_s buffer_data = { NULL, 0 };
+ net_nfc_data_s buffer_data = { NULL, 0 };
net_nfc_client_se_ese_detected_event callback =
(net_nfc_client_se_ese_detected_event)se_esedetecthandler.se_ese_detected_cb;
- net_nfc_util_gdbus_variant_to_data_s(arg_data, &buffer_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_data, &buffer_data);
callback((net_nfc_target_handle_h)GUINT_TO_POINTER(arg_handle),
arg_se_type, &buffer_data,
}
if (callback != NULL) {
- data_s aid = { NULL, 0 };
- data_s param = { NULL, 0 };
+ net_nfc_data_s aid = { NULL, 0 };
+ net_nfc_data_s param = { NULL, 0 };
- net_nfc_util_gdbus_variant_to_data_s(arg_aid, &aid);
- net_nfc_util_gdbus_variant_to_data_s(arg_param, ¶m);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_aid, &aid);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(arg_param, ¶m);
callback(arg_se_type, &aid, ¶m, user_data);
if (func_data->se_callback != NULL) {
net_nfc_se_send_apdu_cb se_callback =
(net_nfc_se_send_apdu_cb)func_data->se_callback;
- data_s data = { NULL, };
+ net_nfc_data_s data = { NULL, };
- net_nfc_util_gdbus_variant_to_data_s(out_response, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(out_response, &data);
se_callback(result, &data, func_data->se_data);
if (func_data->se_callback != NULL) {
net_nfc_se_get_atr_cb se_callback =
(net_nfc_se_get_atr_cb)func_data->se_callback;
- data_s data = { NULL, };
+ net_nfc_data_s data = { NULL, };
- net_nfc_util_gdbus_variant_to_data_s(out_atr, &data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(out_atr, &data);
se_callback(result, &data, func_data->se_data);
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_se_get_atr_sync(
nfc_se_h handle,
- data_h *atr)
+ net_nfc_data_h *atr)
{
net_nfc_error_e result = NET_NFC_OK;
GVariant *out_atr = NULL;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_se_send_apdu(
nfc_se_h handle,
- data_h apdu_data,
+ net_nfc_data_h apdu_data,
net_nfc_se_send_apdu_cb callback,
void *user_data)
{
/* allow this function even nfc is off */
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)apdu_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)apdu_data);
if (arg_data == NULL)
return NET_NFC_INVALID_PARAM;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_se_send_apdu_sync(
nfc_se_h handle,
- data_h apdu_data,
- data_h *response)
+ net_nfc_data_h apdu_data,
+ net_nfc_data_h *response)
{
net_nfc_error_e result = NET_NFC_OK;
GVariant *out_data = NULL;
/* allow this function even nfc is off */
- arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)apdu_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)apdu_data);
if (arg_data == NULL)
return NET_NFC_INVALID_PARAM;
&resp_msg,
NULL,
&error) == TRUE) {
- data_s ndef_data = { NULL, };
+ net_nfc_data_s ndef_data = { NULL, };
- net_nfc_util_gdbus_variant_to_data_s(resp_msg, &ndef_data);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(resp_msg, &ndef_data);
if (ndef_data.buffer != NULL && ndef_data.length > 0) {
result = net_nfc_create_ndef_message_from_rawdata(
while (i < number_of_keys) {
gchar *str = NULL;
- data_h value = NULL;
+ net_nfc_data_h value = NULL;
/* key */
length = *pos; /* first values is length of key */
info_data->number_of_keys = number_of_keys;
info_data->tag_info_list = list;
- net_nfc_util_gdbus_variant_to_data_s(raw_data,
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(raw_data,
&info_data->raw_data);
*info = info_data;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_get_tag_info_value_from_key(net_nfc_target_info_s* target_info, const char* key, int valid_length, data_h* data)
+net_nfc_error_e net_nfc_get_tag_info_value_from_key(net_nfc_target_info_s* target_info, const char* key, int valid_length, net_nfc_data_h* data)
{
if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
key,
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)*data)->length != valid_length)
+ if (((net_nfc_data_s*)*data)->length != valid_length)
return NET_NFC_OUT_OF_BOUND;
return NET_NFC_OK;
net_nfc_error_e net_nfc_client_barcode_get_barcode_sync(
unsigned char **barcode, int* barcode_len)
{
- data_s *data;
+ net_nfc_data_s *data;
GError *error = NULL;
GVariant *out_barcode = NULL;
net_nfc_error_e result = NET_NFC_OK;
}
if (result == NET_NFC_OK) {
- data = g_new0(data_s, 1);
- net_nfc_util_gdbus_variant_to_data_s(out_barcode, data);
+ data = g_new0(net_nfc_data_s, 1);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(out_barcode, data);
if (data == NULL)
return NET_NFC_OPERATION_FAIL;
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[6] = { 0x00, };
rawdata.length = 6;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h IDm = NULL;
+ net_nfc_data_h IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
send_buffer++;
/* set IDm */
- memcpy(send_buffer, ((data_s*)IDm)->buffer, ((data_s*)IDm)->length);
- send_buffer = send_buffer + ((data_s*)IDm)->length;
+ memcpy(send_buffer, ((net_nfc_data_s*)IDm)->buffer, ((net_nfc_data_s*)IDm)->length);
+ send_buffer = send_buffer + ((net_nfc_data_s*)IDm)->length;
/* set the number of service codes */
*send_buffer = number_of_area_service;
net_nfc_error_e result = NET_NFC_OK;
result = net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h IDm = NULL;
+ net_nfc_data_h IDm = NULL;
uint8_t send_buffer[10] = { 0x00, };
send_buffer[1] = FELICA_CMD_REQ_RESPONSE;
memcpy(send_buffer + 2,
- ((data_s*)IDm)->buffer,
- ((data_s*)IDm)->length);
+ ((net_nfc_data_s*)IDm)->buffer,
+ ((net_nfc_data_s*)IDm)->length);
DEBUG_MSG_PRINT_BUFFER(send_buffer, 10);
rawdata.length = 10;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h IDm = NULL;
+ net_nfc_data_h IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
*send_buffer = FELICA_CMD_READ_WITHOUT_ENC;
send_buffer++;
- memcpy(send_buffer, ((data_s*)IDm)->buffer, ((data_s*)IDm)->length);
- send_buffer = send_buffer + ((data_s*)IDm)->length;
+ memcpy(send_buffer, ((net_nfc_data_s*)IDm)->buffer, ((net_nfc_data_s*)IDm)->length);
+ send_buffer = send_buffer + ((net_nfc_data_s*)IDm)->length;
*send_buffer = number_of_services;
send_buffer++;
net_nfc_error_e result = NET_NFC_OK;
result = net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
uint16_t service_list[],
uint8_t number_of_blocks,
uint8_t block_list[],
- data_h data,
+ net_nfc_data_h data,
nfc_transceive_data_callback callback,
void *user_data)
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h IDm = NULL;
+ net_nfc_data_h IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
if (number_of_services > 16)
return NET_NFC_OUT_OF_BOUND;
- if (((data_s*)data)->length > 16 * number_of_blocks)
+ if (((net_nfc_data_s*)data)->length > 16 * number_of_blocks)
return NET_NFC_OUT_OF_BOUND;
send_buffer_length = 1 + 1 + 8 + 1 + (2 * number_of_services)
+ 1 + number_of_blocks
- +((data_s*)data)->length;
+ +((net_nfc_data_s*)data)->length;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
*send_buffer = FELICA_CMD_WRITE_WITHOUT_ENC;
send_buffer++;
- memcpy(send_buffer, ((data_s*)IDm)->buffer, ((data_s*)IDm)->length);
- send_buffer = send_buffer + ((data_s*)IDm)->length;
+ memcpy(send_buffer, ((net_nfc_data_s*)IDm)->buffer, ((net_nfc_data_s*)IDm)->length);
+ send_buffer = send_buffer + ((net_nfc_data_s*)IDm)->length;
*send_buffer = number_of_services;
send_buffer++;
send_buffer++;
}
- memcpy(send_buffer, ((data_s*)data)->buffer, ((data_s*)data)->length);
+ memcpy(send_buffer, ((net_nfc_data_s*)data)->buffer, ((net_nfc_data_s*)data)->length);
DEBUG_MSG_PRINT_BUFFER(temp, send_buffer_length);
net_nfc_error_e result = NET_NFC_OK;
result = net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h IDm = NULL;
+ net_nfc_data_h IDm = NULL;
uint8_t send_buffer[10] = { 0x00, };
send_buffer[1] = FELICA_CMD_REQ_SYSTEM_CODE;
memcpy(send_buffer + 2,
- ((data_s *)IDm)->buffer,
- ((data_s *)IDm)->length);
+ ((net_nfc_data_s *)IDm)->buffer,
+ ((net_nfc_data_s *)IDm)->length);
DEBUG_MSG_PRINT_BUFFER(send_buffer, 10);
rawdata.length = 10;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[9] = {0x00, };
rawdata.length = 9;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t send_buffer[9] = {0x00, };
/* UID0 ~ 3 */
memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ ((net_nfc_data_s*)UID)->buffer,
+ ((net_nfc_data_s*)UID)->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.length = 9;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t send_buffer[9] = {0x00, };
/* UID0 ~ 3 */
memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ ((net_nfc_data_s*)UID)->buffer,
+ ((net_nfc_data_s*)UID)->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.length = 9;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t send_buffer[9] = {0x00, };
/* UID0 ~ 3 */
memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ ((net_nfc_data_s*)UID)->buffer,
+ ((net_nfc_data_s*)UID)->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.length = 9;
return net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t send_buffer[9] = {0x00, };
/* UID0 ~ 3 */
memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ ((net_nfc_data_s*)UID)->buffer,
+ ((net_nfc_data_s*)UID)->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.length = 9;
return net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyA(
net_nfc_target_handle_h handle,
uint8_t sector,
- data_h auth_key,
+ net_nfc_data_h auth_key,
void *callback,
void *user_data)
{
net_nfc_target_info_s* target_info = NULL;
- data_s *key;
- data_s rawdata;
+ net_nfc_data_s *key;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t* send_buffer = NULL;
uint8_t* temp = NULL;
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_OPERATION_FAIL;
- key = (data_s *)auth_key;
+ key = (net_nfc_data_s *)auth_key;
if (key->length != 6)
return NET_NFC_OUT_OF_BOUND;
/* cmd + addr + UID + AUTH_KEY + CRC_A */
- send_buffer_length = 1 + 1 + ((data_s*)UID)->length
+ send_buffer_length = 1 + 1 + ((net_nfc_data_s*)UID)->length
+ key->length + 2;
_net_nfc_util_alloc_mem(send_buffer,
*temp = sector_to_block;
temp++;
- memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
- temp = temp + ((data_s*)UID)->length;
+ memcpy(temp, ((net_nfc_data_s*)UID)->buffer, ((net_nfc_data_s*)UID)->length);
+ temp = temp + ((net_nfc_data_s*)UID)->length;
memcpy(temp, key->buffer, key->length);
rawdata.length = send_buffer_length;
net_nfc_error_e result = net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyB(
net_nfc_target_handle_h handle,
uint8_t sector,
- data_h auth_key,
+ net_nfc_data_h auth_key,
void *callback,
void *user_data)
{
net_nfc_target_info_s* target_info = NULL;
- data_s *key;
- data_s rawdata;
+ net_nfc_data_s *key;
+ net_nfc_data_s rawdata;
- data_h UID = NULL;
+ net_nfc_data_h UID = NULL;
uint8_t* send_buffer = NULL;
uint8_t* temp = NULL;
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_OPERATION_FAIL;
- key = (data_s *)auth_key;
+ key = (net_nfc_data_s *)auth_key;
if (key->length != 6)
return NET_NFC_OUT_OF_BOUND;
break;
}
- send_buffer_length = 1 + 1 + ((data_s*)UID)->length
+ send_buffer_length = 1 + 1 + ((net_nfc_data_s*)UID)->length
+ key->length + 2; /* cmd + addr + UID + AUTH_KEY + CRC_A */
_net_nfc_util_alloc_mem(send_buffer, send_buffer_length
*temp = sector_to_block;
temp++;
- memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
- temp = temp + ((data_s*)UID)->length;
+ memcpy(temp, ((net_nfc_data_s*)UID)->buffer, ((net_nfc_data_s*)UID)->length);
+ temp = temp + ((net_nfc_data_s*)UID)->length;
memcpy(temp, key->buffer, key->length);
rawdata.length = send_buffer_length;
net_nfc_error_e result = net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[2] = { 0 };
rawdata.length = 2;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
}
net_nfc_error_e net_nfc_client_mifare_write_block(
net_nfc_target_handle_h handle,
uint8_t addr,
- data_h data,
+ net_nfc_data_h data,
void *callback,
void *user_data)
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t* send_buffer = NULL;
}
if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
- if (((data_s *)data)->length > MIFARE_PAGE_SIZE) {
+ if (((net_nfc_data_s *)data)->length > MIFARE_PAGE_SIZE) {
uint8_t* temp = NULL;
/* cmd + addr + page */
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->buffer,
MIFARE_PAGE_SIZE);
} else {
/* cmd + addr + page */
send_buffer_length = 1 + 1 +
- ((data_s*)data)->length;
+ ((net_nfc_data_s*)data)->length;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ ((net_nfc_data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->length);
}
} else {
- if (((data_s*)data)->length > MIFARE_BLOCK_SIZE) {
+ if (((net_nfc_data_s*)data)->length > MIFARE_BLOCK_SIZE) {
uint8_t* temp = NULL;
/* cmd + addr + page*/
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->buffer,
MIFARE_BLOCK_SIZE);
} else {
uint8_t* temp = NULL;
/* cmd + addr + page */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length;
+ send_buffer_length = 1 + 1 + ((net_nfc_data_s*)data)->length;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ ((net_nfc_data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->length);
}
}
rawdata.length = send_buffer_length;
net_nfc_error_e result = net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
net_nfc_error_e net_nfc_client_mifare_write_page(
net_nfc_target_handle_h handle,
uint8_t addr,
- data_h data,
+ net_nfc_data_h data,
void *callback,
void *user_data)
{
}
if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC) {
- if (((data_s*)data)->length > MIFARE_PAGE_SIZE) {
+ if (((net_nfc_data_s*)data)->length > MIFARE_PAGE_SIZE) {
uint8_t* temp = NULL;
/* cmd + addr + page */
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->buffer,
MIFARE_PAGE_SIZE);
} else {
uint8_t* temp = NULL;
/* cmd + addr + page */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length;
+ send_buffer_length = 1 + 1 + ((net_nfc_data_s*)data)->length;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ ((net_nfc_data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->length);
}
} else {
- if (((data_s*)data)->length > MIFARE_PAGE_SIZE) {
+ if (((net_nfc_data_s*)data)->length > MIFARE_PAGE_SIZE) {
uint8_t* temp = NULL;
/* cmd + addr + page */
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->buffer,
MIFARE_PAGE_SIZE);
} else {
uint8_t* temp = NULL;
/* cmd + addr + page */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length;
+ send_buffer_length = 1 + 1 + ((net_nfc_data_s*)data)->length;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
temp++;
memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ ((net_nfc_data_s*)data)->buffer,
+ ((net_nfc_data_s*)data)->length);
}
}
- data_s rawdata;
+ net_nfc_data_s rawdata;
rawdata.buffer = send_buffer;
rawdata.length = send_buffer_length;
net_nfc_error_e result = net_nfc_client_transceive(handle,
- (data_h)&rawdata,
+ (net_nfc_data_h)&rawdata,
callback,
user_data);
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[8] = { 0 };
rawdata.buffer = send_buffer;
rawdata.length = 8;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, (net_nfc_data_h)&rawdata, callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[8] = { 0 };
rawdata.buffer = send_buffer;
rawdata.length = 8;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, (net_nfc_data_h)&rawdata, callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[4] = { 0 };
rawdata.buffer = send_buffer;
rawdata.length = 4;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, (net_nfc_data_h)&rawdata, callback,
user_data);
}
{
net_nfc_target_info_s* target_info = NULL;
- data_s rawdata;
+ net_nfc_data_s rawdata;
uint8_t send_buffer[4] = { 0 };
rawdata.buffer = send_buffer;
rawdata.length = 4;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, (net_nfc_data_h)&rawdata, callback,
user_data);
}
NET_NFC_EXPORT_API
-net_nfc_error_e net_nfc_client_mifare_create_default_key(data_h* key)
+net_nfc_error_e net_nfc_client_mifare_create_default_key(net_nfc_data_h* key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_mifare_create_application_directory_key(
- data_h* key)
+ net_nfc_data_h* key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
}
NET_NFC_EXPORT_API
-net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(data_h* key)
+net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(net_nfc_data_h* key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_get_tag_info_value(net_nfc_target_info_h target_info,
- const char *key, data_h *value)
+ const char *key, net_nfc_data_h *value)
{
net_nfc_target_info_s *handle = (net_nfc_target_info_s *)target_info;
net_nfc_tag_info_s *tag_info;
return NET_NFC_NULL_PARAMETER;
result = net_nfc_create_ndef_message_from_rawdata(msg,
- (data_h)&target_info_private->raw_data);
+ (net_nfc_data_h)&target_info_private->raw_data);
return result;
}
_net_nfc_util_strdup(temp->tag_info_list[i].key, handle->tag_info_list[i].key);
if (handle->tag_info_list[i].value != NULL) {
- data_s *data = (data_s *)handle->tag_info_list[i].value;
+ net_nfc_data_s *data = (net_nfc_data_s *)handle->tag_info_list[i].value;
net_nfc_create_data(&temp->tag_info_list[i].value, data->buffer, data->length);
}
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_test_set_ee_data(int mode,
int reg_id,
- data_h data,
+ net_nfc_data_h data,
net_nfc_client_test_set_ee_data_completed callback,
void *user_data)
{
func_data->callback = (gpointer)callback;
func_data->user_data = user_data;
- variant = net_nfc_util_gdbus_data_to_variant((data_s *)data);
+ variant = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)data);
net_nfc_gdbus_test_call_set_ee_data(test_proxy,
mode,
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_test_set_ee_data_sync(int mode,
int reg_id,
- data_h data)
+ net_nfc_data_h data)
{
net_nfc_error_e out_result = NET_NFC_OK;
GVariant *variant = NULL;
if (net_nfc_client_manager_is_activated() == false)
return NET_NFC_NOT_ACTIVATED;
- variant = net_nfc_util_gdbus_data_to_variant((data_s *)data);
+ variant = net_nfc_util_gdbus_data_to_variant((net_nfc_data_s *)data);
if (net_nfc_gdbus_test_call_set_ee_data_sync(test_proxy,
mode,
static GVariant *transceive_data_to_transceive_variant(
net_nfc_target_type_e dev_type,
- data_s *data);
+ net_nfc_data_s *data);
static void transceive_call(GObject *source_object,
GAsyncResult *res,
static GVariant *transceive_data_to_transceive_variant(
net_nfc_target_type_e devType,
- data_s *data)
+ net_nfc_data_s *data)
{
- data_s transceive_info = { NULL, };
+ net_nfc_data_s transceive_info = { NULL, };
GVariant *variant;
if (data == NULL) {
}
if (func_data->callback != NULL) {
- data_s resp = { NULL, };
+ net_nfc_data_s resp = { NULL, };
- net_nfc_util_gdbus_variant_to_data_s(out_data, &resp);
+ net_nfc_util_gdbus_variant_to_net_nfc_data_s(out_data, &resp);
((nfc_transceive_data_callback)func_data->callback)(
out_result,
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_h handle,
- data_h rawdata,
+ net_nfc_data_h rawdata,
nfc_transceive_callback callback,
void *user_data)
{
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_transceive_data(net_nfc_target_handle_h handle,
- data_h rawdata,
+ net_nfc_data_h rawdata,
nfc_transceive_data_callback callback,
void *user_data)
{
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_transceive_sync(net_nfc_target_handle_h handle,
- data_h rawdata)
+ net_nfc_data_h rawdata)
{
net_nfc_target_info_s *target_info;
net_nfc_error_e out_result = NET_NFC_OK;
NET_NFC_EXPORT_API
net_nfc_error_e net_nfc_client_transceive_data_sync(
net_nfc_target_handle_h handle,
- data_h rawdata,
- data_h *response)
+ net_nfc_data_h rawdata,
+ net_nfc_data_h *response)
{
net_nfc_target_info_s *target_info;
net_nfc_error_e out_result = NET_NFC_OK;
unsigned int *resp_len)
{
net_nfc_error_e result;
- data_h command = NULL; // LCOV_EXCL_LINE
+ net_nfc_data_h command = NULL; // LCOV_EXCL_LINE
LOG_BEGIN(); // LCOV_EXCL_LINE
result = net_nfc_create_data(&command, cmd, cmd_len);
if (result == NET_NFC_OK) {
- data_h response = NULL;
+ net_nfc_data_h response = NULL;
result = net_nfc_client_se_send_apdu_sync(
handle,
int nfc_se_get_atr_internal(nfc_se_h handle, unsigned char **atr, unsigned int *atr_len)
{
net_nfc_error_e result;
- data_h response = NULL; // LCOV_EXCL_LINE
+ net_nfc_data_h response = NULL; // LCOV_EXCL_LINE
LOG_BEGIN(); // LCOV_EXCL_LINE
int nfc_hce_send_apdu_response(nfc_se_h handle, unsigned char *resp, unsigned int resp_len)
{
net_nfc_error_e result;
- data_h data;
+ net_nfc_data_h data;
LOG_BEGIN(); // LCOV_EXCL_LINE
}
}
-char * nfc_common_get_bt_address_string(data_h data)
+char * nfc_common_get_bt_address_string(net_nfc_data_h data)
{
uint8_t *buffer;
uint32_t length;
}
/* LCOV_EXCL_START */
-static void _se_transaction_event_cb(net_nfc_se_type_e se_type, data_h aid,
- data_h param, void *user_data)
+static void _se_transaction_event_cb(net_nfc_se_type_e se_type, net_nfc_data_h aid,
+ net_nfc_data_h param, void *user_data)
{
LOG_BEGIN();
/* LCOV_EXCL_START */
static void _hce_event_cb(net_nfc_target_handle_h handle,
- net_nfc_hce_event_t event, data_h apdu, void *user_data)
+ net_nfc_hce_event_t event, net_nfc_data_h apdu, void *user_data)
{
LOG_BEGIN();
unsigned int payload_size)
{
int ret;
- data_h type_data = NULL;
- data_h id_data = NULL;
- data_h payload_data = NULL;
+ net_nfc_data_h type_data = NULL;
+ net_nfc_data_h id_data = NULL;
+ net_nfc_data_h payload_data = NULL;
LOG_BEGIN();
int id_size)
{
int ret;
- data_h id_data = NULL;
+ net_nfc_data_h id_data = NULL;
LOG_BEGIN();
unsigned int *size)
{
int ret;
- data_h payload_data;
+ net_nfc_data_h payload_data;
LOG_BEGIN();
int *size)
{
int ret;
- data_h type_data;
+ net_nfc_data_h type_data;
LOG_BEGIN();
int *size)
{
int ret;
- data_h id_data;
+ net_nfc_data_h id_data;
LOG_BEGIN();
unsigned int rawdata_size)
{
int ret;
- data_h rawdata_data = NULL;
+ net_nfc_data_h rawdata_data = NULL;
LOG_BEGIN();
unsigned int *rawdata_size)
{
int ret;
- data_h rawdata_data;
+ net_nfc_data_h rawdata_data;
LOG_BEGIN();
void *user_data)
{
int ret;
- data_h rawdata;
+ net_nfc_data_h rawdata;
LOG_BEGIN();
void *user_data)
{
int ret;
- data_h rawdata;
+ net_nfc_data_h rawdata;
GVariant *parameter;
LOG_BEGIN();
}
/* LCOV_EXCL_START */
-static void _p2p_set_data_received_cb(data_h data, void *user_data)
+static void _p2p_set_data_received_cb(net_nfc_data_h data, void *user_data)
{
LOG_BEGIN();
/* LCOV_EXCL_START */
static void _p2p_handover_cb(net_nfc_error_e result,
- net_nfc_conn_handover_carrier_type_e carrier, data_h ac_data, void *user_data)
+ net_nfc_conn_handover_carrier_type_e carrier, net_nfc_data_h ac_data, void *user_data)
{
nfc_p2p_connection_handover_completed_cb callback;
void *user_param;
net_nfc_handover_event_e event,
net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e carrier,
- data_h ac_data,
- data_h ndef_message,
+ net_nfc_data_h ac_data,
+ net_nfc_data_h ndef_message,
void *user_data)
{
LOG_BEGIN();
free(user_param);
}
-static void _tag_transceive_data_cb(net_nfc_error_e result, data_h arg_data, void* user_data)
+static void _tag_transceive_data_cb(net_nfc_error_e result, net_nfc_data_h arg_data, void* user_data)
{
nfc_callback_s* user_param = user_data;
nfc_tag_transceive_completed_cb callback = NULL;
free(user_param);
}
-static void _mifare_read_block_cb(net_nfc_error_e result, data_h data, void* user_data)
+static void _mifare_read_block_cb(net_nfc_error_e result, net_nfc_data_h data, void* user_data)
{
nfc_callback_s* user_param = user_data;
nfc_mifare_read_block_completed_cb callback;
void* user_data)
{
int ret;
- data_h key_data = NULL;
+ net_nfc_data_h key_data = NULL;
LOG_BEGIN();
void* user_data)
{
int ret;
- data_h rawdata = NULL;
+ net_nfc_data_h rawdata = NULL;
CHECK_SUPPORTED(NFC_TAG_FEATURE);
int ret;
int i, count = 0;
char **keys = NULL;
- data_h value = NULL;
+ net_nfc_data_h value = NULL;
bool cont;
void *user_data)
{
int ret;
- data_h auth_key_data = NULL;
+ net_nfc_data_h auth_key_data = NULL;
CHECK_SUPPORTED(NFC_TAG_FEATURE);
void *user_data)
{
int ret;
- data_h auth_key_data = NULL;
+ net_nfc_data_h auth_key_data = NULL;
LOG_BEGIN();
void *user_data)
{
int ret;
- data_h block_data = NULL;
+ net_nfc_data_h block_data = NULL;
LOG_BEGIN();
void *user_data)
{
int ret;
- data_h block_data = NULL;
+ net_nfc_data_h block_data = NULL;
LOG_BEGIN();
CHECK_SUPPORTED(NFC_TAG_FEATURE);
projects / platform / core / api / nfc.git / commitdiff