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,
+ data_s *ac_data,
void *user_data);
net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle);
+ net_nfc_connection_handover_info_s *info_handle);
net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_type(
- net_nfc_connection_handover_info_h info_handle,
+ net_nfc_connection_handover_info_s *info_handle,
net_nfc_conn_handover_carrier_type_e *type);
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_connection_handover_info_s *info_handle, data_s **data);
net_nfc_error_e net_nfc_client_p2p_connection_handover(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_p2p_connection_handover_completed_cb callback,
void *cb_data);
net_nfc_error_e net_nfc_client_p2p_connection_handover_sync(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_conn_handover_carrier_type_e *out_carrier,
- data_h *out_ac_data);
+ data_s **out_ac_data);
/* TODO : move to internal header */
net_nfc_error_e net_nfc_client_handover_init(void);
void *user_data);
typedef void (*net_nfc_client_llcp_receive_completed) (net_nfc_error_e result,
- data_h data,
+ data_s *data,
void *user_data);
typedef void (*net_nfc_client_llcp_receive_from_completed) (
net_nfc_error_e result,
sap_t sap,
- data_h data,
+ data_s *data,
void *user_data);
typedef void (*net_nfc_client_llcp_close_completed) (net_nfc_error_e result,
typedef void (*net_nfc_client_llcp_disconnect_completed)(net_nfc_error_e result,
void *user_data);
-net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config,
+net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_s *config,
net_nfc_client_llcp_config_completed callback, void *user_data);
-net_nfc_error_e net_nfc_client_llcp_config_sync
-(net_nfc_llcp_config_info_h config);
+net_nfc_error_e net_nfc_client_llcp_config_sync(
+ net_nfc_llcp_config_info_s *config);
-net_nfc_error_e net_nfc_client_llcp_get_config
-(net_nfc_llcp_config_info_h *config);
+net_nfc_error_e net_nfc_client_llcp_get_config(net_nfc_llcp_config_info_s **config);
net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
const char *service_name,
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,
+ data_s *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);
+ data_s *data);
net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data,
+ data_s *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);
+ sap_t sap, data_s *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);
+ data_s **out_data);
net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
size_t request_length,
net_nfc_error_e net_nfc_client_llcp_receive_from_sync(net_nfc_llcp_socket_t socket,
size_t request_length,
sap_t *out_sap,
- data_h *out_data);
+ data_s **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_llcp_socket_t socket);
void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
- net_nfc_llcp_socket_option_h option);
+ net_nfc_llcp_socket_option_s *option);
net_nfc_error_e net_nfc_client_llcp_get_local_config(
- net_nfc_llcp_config_info_h *config);
+ net_nfc_llcp_config_info_s **config);
net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
- net_nfc_llcp_socket_t socket,
- net_nfc_llcp_socket_option_h *option);
+ net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s **option);
net_nfc_error_e net_nfc_client_llcp_create_socket_option(
- net_nfc_llcp_socket_option_h *option,
+ net_nfc_llcp_socket_option_s **option,
uint16_t miu,
uint8_t rw,
net_nfc_socket_type_e type);
net_nfc_error_e net_nfc_client_llcp_socket_option_default(
- net_nfc_llcp_socket_option_h *option);
+ net_nfc_llcp_socket_option_s **option);
net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
- net_nfc_llcp_socket_option_h option,
- uint16_t *miu);
+ net_nfc_llcp_socket_option_s *option, uint16_t *miu);
net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
- net_nfc_llcp_socket_option_h option,
- uint16_t miu);
+ net_nfc_llcp_socket_option_s *option, uint16_t miu);
net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
- net_nfc_llcp_socket_option_h option,
- uint8_t *rt);
+ net_nfc_llcp_socket_option_s *option, uint8_t *rt);
net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
- net_nfc_llcp_socket_option_h option,
- uint8_t rt);
+ net_nfc_llcp_socket_option_s *option, uint8_t rt);
net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
- net_nfc_llcp_socket_option_h option,
- net_nfc_socket_type_e *type);
+ net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e *type);
net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
- net_nfc_llcp_socket_option_h option,
- net_nfc_socket_type_e type);
+ net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e type);
net_nfc_error_e net_nfc_client_llcp_free_socket_option(
- net_nfc_llcp_socket_option_h option);
+ net_nfc_llcp_socket_option_s * option);
net_nfc_error_e net_nfc_client_llcp_create_config(
- net_nfc_llcp_config_info_h *config,
+ net_nfc_llcp_config_info_s **config,
uint16_t miu,
uint16_t wks,
uint8_t lto,
uint8_t option);
net_nfc_error_e net_nfc_client_llcp_create_config_default(
- net_nfc_llcp_config_info_h *config);
+ net_nfc_llcp_config_info_s **config);
net_nfc_error_e net_nfc_client_llcp_get_config_miu(
- net_nfc_llcp_config_info_h config,
- uint16_t *miu);
+ net_nfc_llcp_config_info_s *config, uint16_t *miu);
net_nfc_error_e net_nfc_client_llcp_get_config_wks(
- net_nfc_llcp_config_info_h config,
- uint16_t *wks);
+ net_nfc_llcp_config_info_s *config, uint16_t *wks);
net_nfc_error_e net_nfc_client_llcp_get_config_lto(
- net_nfc_llcp_config_info_h config, uint8_t *lto);
+ net_nfc_llcp_config_info_s *config, uint8_t *lto);
net_nfc_error_e net_nfc_client_llcp_get_config_option(
- net_nfc_llcp_config_info_h config, uint8_t *option);
+ net_nfc_llcp_config_info_s *config, uint8_t *option);
net_nfc_error_e net_nfc_client_llcp_set_config_miu(
- net_nfc_llcp_config_info_h config, uint16_t miu);
+ net_nfc_llcp_config_info_s *config, uint16_t miu);
net_nfc_error_e net_nfc_client_llcp_set_config_wks(
- net_nfc_llcp_config_info_h config, uint16_t wks);
+ net_nfc_llcp_config_info_s *config, uint16_t wks);
net_nfc_error_e net_nfc_client_llcp_set_config_lto(
- net_nfc_llcp_config_info_h config, uint8_t lto);
+ net_nfc_llcp_config_info_s *config, uint8_t lto);
net_nfc_error_e net_nfc_client_llcp_set_config_option(
- net_nfc_llcp_config_info_h config, uint8_t option);
+ net_nfc_llcp_config_info_s *config, uint8_t option);
net_nfc_error_e net_nfc_client_llcp_free_config(
- net_nfc_llcp_config_info_h config);
+ net_nfc_llcp_config_info_s *config);
net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
- net_nfc_llcp_socket_option_h *option);
+ net_nfc_llcp_socket_option_s **option);
net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
sap_t sap, net_nfc_client_llcp_connect_sap_completed callback, void *user_data);
#include "net_nfc_typedef.h"
typedef void (*net_nfc_client_ndef_read_completed) (net_nfc_error_e result,
- ndef_message_h message, void *user_data);
+ ndef_message_s *message, void *user_data);
typedef void (*net_nfc_client_ndef_write_completed) (net_nfc_error_e result,
void *user_data);
typedef void (*net_nfc_client_ndef_format_completed) (net_nfc_error_e result,
void *user_data);
-net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_s *handle,
net_nfc_client_ndef_read_completed callback,
void *user_data);
-net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle,
- ndef_message_h *message);
+net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_s *handle,
+ ndef_message_s **message);
-net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle,
- ndef_message_h message, net_nfc_client_ndef_write_completed callback, void *user_data);
+net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_s *handle,
+ ndef_message_s *message, net_nfc_client_ndef_write_completed callback, void *user_data);
-net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handle,
- ndef_message_h message);
+net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_s *handle,
+ ndef_message_s *message);
net_nfc_error_e net_nfc_client_ndef_make_read_only(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_client_ndef_make_read_only_completed callback,
void *user_data);
net_nfc_error_e net_nfc_client_ndef_make_read_only_sync(
- net_nfc_target_handle_h handle);
+ net_nfc_target_handle_s *handle);
-net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
- data_h key, net_nfc_client_ndef_format_completed callback, void *user_data);
+net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_s *handle,
+ data_s *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_error_e net_nfc_client_ndef_format_sync(net_nfc_target_handle_s *handle,
+ data_s *key);
/* TODO : move to internal header */
net_nfc_error_e net_nfc_client_ndef_init(void);
typedef void (*net_nfc_client_p2p_send_completed)(net_nfc_error_e result,
void *user_data);
-typedef void (*net_nfc_client_p2p_device_discovered)(net_nfc_target_handle_h handle_info,
- void *user_data);
+typedef void (*net_nfc_client_p2p_device_discovered)(
+ net_nfc_target_handle_s *handle_info,void *user_data);
typedef void (*net_nfc_client_p2p_device_detached)(void *user_data);
-typedef void (*net_nfc_client_p2p_data_received)(data_h p2p_data, void *user_data);
+typedef void (*net_nfc_client_p2p_data_received)(data_s *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_client_p2p_send_completed callback, void *user_data);
+net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_s *handle,
+ data_s *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_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_s *handle,
+ data_s *data);
/* P2P client API's - used for registering callbacks*/
void *user_data);
typedef void (*net_nfc_se_open_se_cb)(net_nfc_error_e result,
- net_nfc_target_handle_h handle, void *user_data);
+ net_nfc_target_handle_s *handle, void *user_data);
typedef void (*net_nfc_se_close_se_cb)(net_nfc_error_e result, void *user_data);
-typedef void (*net_nfc_se_get_atr_cb)(net_nfc_error_e result, data_h data,
+typedef void (*net_nfc_se_get_atr_cb)(net_nfc_error_e result, data_s *data,
void *user_data);
-typedef void (*net_nfc_se_send_apdu_cb)(net_nfc_error_e result, data_h data,
+typedef void (*net_nfc_se_send_apdu_cb)(net_nfc_error_e result, data_s *data,
void *user_data);
typedef void (*net_nfc_client_se_event)(net_nfc_message_e event, void *user_data);
-typedef void (*net_nfc_client_se_transaction_event)(data_h aid, data_h param,
+typedef void (*net_nfc_client_se_transaction_event)(data_s *aid, data_s *param,
void *user_data);
typedef void (*net_nfc_client_se_ese_detected_event)(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
int dev_type,
- data_h data,
+ data_s *data,
void *user_data);
/************* Secure Element API's*************/
void *user_data);
net_nfc_error_e net_nfc_client_se_open_internal_secure_element_sync(
- net_nfc_se_type_e se_type, net_nfc_target_handle_h *handle);
+ net_nfc_se_type_e se_type, net_nfc_target_handle_s **handle);
net_nfc_error_e net_nfc_client_se_close_internal_secure_element(
- net_nfc_target_handle_h handle,
- net_nfc_se_close_se_cb callback,
- void *user_data);
+ net_nfc_target_handle_s *handle, net_nfc_se_close_se_cb callback, void *user_data);
net_nfc_error_e net_nfc_client_se_close_internal_secure_element_sync(
- net_nfc_target_handle_h handle);
+ net_nfc_target_handle_s *handle);
-net_nfc_error_e net_nfc_client_se_get_atr(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_se_get_atr(net_nfc_target_handle_s *handle,
net_nfc_se_get_atr_cb callback, void *user_data);
-net_nfc_error_e net_nfc_client_se_get_atr_sync(net_nfc_target_handle_h handle,
- data_h *atr);
+net_nfc_error_e net_nfc_client_se_get_atr_sync(net_nfc_target_handle_s *handle,
+ data_s **atr);
-net_nfc_error_e net_nfc_client_se_send_apdu(net_nfc_target_handle_h handle,
- data_h apdu_data, net_nfc_se_send_apdu_cb callback, void *user_data);
+net_nfc_error_e net_nfc_client_se_send_apdu(net_nfc_target_handle_s *handle,
+ data_s *apdu_data, net_nfc_se_send_apdu_cb callback, void *user_data);
net_nfc_error_e net_nfc_client_se_send_apdu_sync(
- net_nfc_target_handle_h handle, data_h apdu_data, data_h *response);
+ net_nfc_target_handle_s *handle, data_s *apdu_data, data_s **response);
/************* Secure Element CallBack Register/Deregister functions*************/
net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data);
net_nfc_error_e net_nfc_client_snep_start_server(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
const char *san,
sap_t sap,
net_nfc_client_snep_event_cb callback,
void *user_data);
net_nfc_error_e net_nfc_client_snep_start_client(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
const char *san,
sap_t sap,
net_nfc_client_snep_event_cb callback,
net_nfc_error_e net_nfc_client_snep_send_client_request(
net_nfc_snep_handle_h handle,
net_nfc_snep_type_t snep_type,
- ndef_message_h msg,
+ ndef_message_s *msg,
net_nfc_client_snep_event_cb callback,
void *user_data);
net_nfc_error_e net_nfc_client_snep_send_client_request_sync(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
net_nfc_snep_type_t snep_type,
- ndef_message_h msg,
+ ndef_message_s *msg,
net_nfc_snep_type_t *resp_type,
- ndef_message_h *response);
+ ndef_message_s **response);
net_nfc_error_e net_nfc_client_snep_stop_service(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
net_nfc_snep_handle_h service,
net_nfc_client_snep_event_cb callback,
void *user_data);
net_nfc_error_e net_nfc_client_snep_stop_service_sync(
- net_nfc_target_handle_h target, net_nfc_snep_handle_h service);
+ net_nfc_target_handle_s *target, net_nfc_snep_handle_h service);
net_nfc_error_e net_nfc_client_snep_register_server(const char *san, sap_t sap,
net_nfc_client_snep_event_cb callback, void *user_data);
#include "net_nfc_typedef.h"
typedef void (*net_nfc_client_popup_set_state_callback)(
- net_nfc_error_e result,
- void *user_data);
+ net_nfc_error_e result,
+ void *user_data);
net_nfc_error_e net_nfc_client_sys_handler_set_state(int state,
- net_nfc_client_popup_set_state_callback callback,
- void *user_data);
+ net_nfc_client_popup_set_state_callback callback,
+ void *user_data);
net_nfc_error_e net_nfc_client_sys_handler_set_state_force(int state,
- net_nfc_client_popup_set_state_callback callback,
- void *user_data);
+ net_nfc_client_popup_set_state_callback callback,
+ void *user_data);
net_nfc_error_e net_nfc_client_sys_handler_set_state_sync(int state);
net_nfc_error_e net_nfc_client_sys_handler_set_launch_popup_state(int enable);
net_nfc_error_e net_nfc_client_sys_handler_set_launch_popup_state_force(
- int enable);
+ int enable);
net_nfc_error_e net_nfc_client_sys_handler_get_launch_popup_state(int *state);
net_nfc_error_e result, net_nfc_target_type_e dev_type, void *user_data);
typedef void (*net_nfc_client_tag_get_current_tag_info_completed)(
- net_nfc_error_e result, net_nfc_target_info_h info, void *user_data);
+ net_nfc_error_e result, net_nfc_target_info_s *info, void *user_data);
typedef void (*net_nfc_client_tag_get_current_target_handle_completed)(
- net_nfc_error_e result, net_nfc_target_handle_h handle, void *user_data);
+ net_nfc_error_e result, net_nfc_target_handle_s *handle, void *user_data);
#endif
-typedef void (*net_nfc_client_tag_tag_discovered)(net_nfc_target_info_h info,
+typedef void (*net_nfc_client_tag_tag_discovered)(net_nfc_target_info_s *info,
void *user_data);
typedef void (*net_nfc_client_tag_tag_detached)(void *user_data);
net_nfc_target_type_e *dev_type);
net_nfc_error_e net_nfc_client_tag_get_current_tag_info_sync(
- net_nfc_target_info_h *info);
+ net_nfc_target_info_s **info);
net_nfc_error_e net_nfc_client_tag_get_current_target_handle_sync(
- net_nfc_target_handle_h *handle);
+ net_nfc_target_handle_s **handle);
void net_nfc_client_tag_set_tag_discovered(
net_nfc_client_tag_tag_discovered callback, void *user_data);
*/
-net_nfc_error_e net_nfc_client_felica_poll(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_felica_poll(net_nfc_target_handle_s *handle,
net_nfc_felica_poll_request_code_e req_code,
uint8_t time_slote,
nfc_transceive_data_callback callback,
*/
net_nfc_error_e net_nfc_client_felica_request_service(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_area_service,
uint16_t area_service_list[],
uint8_t number_of_services,
*/
net_nfc_error_e net_nfc_client_felica_request_response(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback,
void *user_data);
*/
net_nfc_error_e net_nfc_client_felica_read_without_encryption(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_services,
uint16_t service_list[],
uint8_t number_of_blocks,
*/
net_nfc_error_e net_nfc_client_felica_write_without_encryption(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_services,
uint16_t service_list[],
uint8_t number_of_blocks,
uint8_t block_list[],
- data_h data,
+ data_s *data,
nfc_transceive_data_callback callback,
void *user_data);
*/
net_nfc_error_e net_nfc_client_felica_request_system_code(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback,
void* trans_param);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_CLIENT_TAG_FELICA_H__
*/
-net_nfc_error_e net_nfc_client_jewel_read_id(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_jewel_read_id(net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback, void *user_data);
/**
*/
-net_nfc_error_e net_nfc_client_jewel_read_byte(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_jewel_read_byte(net_nfc_target_handle_s *handle,
uint8_t block, uint8_t byte, nfc_transceive_data_callback callback, void *user_data);
/**
*/
-net_nfc_error_e net_nfc_client_jewel_read_all(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_jewel_read_all(net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback, void *user_data);
*/
net_nfc_error_e net_nfc_client_jewel_write_with_erase(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t block,
uint8_t byte,
uint8_t data,
*/
net_nfc_error_e net_nfc_client_jewel_write_with_no_erase(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t block,
uint8_t byte,
uint8_t data,
void *user_data);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_CLIENT_TAG_JEWEL_H__
*/
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyA(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t sector,
- data_h auth_key,
+ data_s *auth_key,
void *callback,
void *user_data);
net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyB(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t sector,
- data_h auth_key,
+ data_s *auth_key,
void *callback,
void *user_data);
@exception NET_NFC_NOT_SUPPORTED you may recieve this error if you request not supported command
@exception NET_NFC_INVALID_HANDLE target handle is not valid
@exception NET_NFC_TAG_READ_FAILED received chunked data is not valied (damaged data is recieved) or error ack is recieved
-*/
+ */
-net_nfc_error_e net_nfc_client_mifare_read(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_mifare_read(net_nfc_target_handle_s *handle,
uint8_t addr, void *callback, void *user_data);
/**
net_nfc_error_e net_nfc_client_mifare_write_block(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
- data_h data,
+ data_s *data,
void *callback,
void *user_data);
*/
net_nfc_error_e net_nfc_client_mifare_write_page(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
- data_h data,
+ data_s *data,
void *callback,
void *user_data);
*/
-net_nfc_error_e net_nfc_client_mifare_increment(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_mifare_increment(net_nfc_target_handle_s *handle,
uint8_t addr, int value, void *callback, void *user_data);
/**
*/
-net_nfc_error_e net_nfc_client_mifare_decrement(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_mifare_decrement(net_nfc_target_handle_s *handle,
uint8_t addr, int value, void *callback, void *user_data);
/**
*/
-net_nfc_error_e net_nfc_client_mifare_transfer(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_mifare_transfer(net_nfc_target_handle_s *handle,
uint8_t addr, void *callback, void *user_data);
/**
*/
-net_nfc_error_e net_nfc_client_mifare_restore(net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_mifare_restore(net_nfc_target_handle_s *handle,
uint8_t addr, 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(data_s **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);
+ data_s **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(data_s **key);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_TAG_MIFARE_H__
void *user_data);
typedef void (*nfc_transceive_data_callback)(net_nfc_error_e result,
- data_h data,
+ data_s *data,
void *user_data);
-net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_h handle,
- data_h rawdata, nfc_transceive_callback callback, void *user_data);
+net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_s *handle,
+ data_s *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, nfc_transceive_data_callback callback, void *user_data);
+net_nfc_error_e net_nfc_client_transceive_data(net_nfc_target_handle_s *handle,
+ data_s *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_error_e net_nfc_client_transceive_sync(net_nfc_target_handle_s *handle,
+ data_s *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_target_handle_s *handle, data_s *rawdata, data_s **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(data_s **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(data_s **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 data_s *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) illigal 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(data_s *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 data_s *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 data_s *data);
/**
free data handler. (it also free the copied bytes)
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_free_data (data_h data);
+net_nfc_error_e net_nfc_free_data (data_s *data);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_DATA_H__
@code
net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
result = net_nfc_create_ndef_message (&msg);
if (result != NET_NFC_OK) return result;
*/
-net_nfc_error_e net_nfc_create_ndef_message (ndef_message_h* ndef_message);
+net_nfc_error_e net_nfc_create_ndef_message(ndef_message_s **ndef_message);
/**
this APIs is the getter of record counts
if(data != NULL)
{
int count = 0;
- ndef_message_h ndef = (ndef_message_h)(data);
+ ndef_message_s *ndef = (ndef_message_s*)data;
net_nfc_get_ndef_message_record_count (ndef, &count);
printf ("record count = %d\n", count);
}
}
@endcode
*/
-net_nfc_error_e net_nfc_get_ndef_message_record_count (ndef_message_h ndef_message, int * count);
+net_nfc_error_e net_nfc_get_ndef_message_record_count (ndef_message_s *ndef_message, int * count);
/**
This function converts the NDEF Message structure to serial bytes of ndef message.
@code
net_nfc_error_e result = NET_NFC_OK;
- data_h rawdata;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ data_s *rawdata;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
int idx;
uint8_t * buffer = NULL;
*/
-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_s *ndef_message, data_s **rawdata);
/**
This function return the structure of ndef_message from serial format of ndef message.
if(data != NULL)
{
record_h record;
- ndef_message_h url;
- data_h ndef_type;
- data_h payload;
+ ndef_message_s *url;
+ data_s *ndef_type;
+ data_s *payload;
- ndef_message_h ndef = (ndef_message_h)(data);
+ ndef_message_s *ndef = (ndef_message_s*)data;
net_nfc_get_record_by_index (ndef, 0, &record);
net_nfc_get_record_type (record, &ndef_type);
if (strncmp (ndef_type.buffer, "Sp", ndef_type.length)){
*/
-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_s **ndef_message, data_s *rawdata);
/**
it returns the total size of ndef message bytes. parse the structure data and count the bytes
to know the length of bytes required to store the NDEF message.
it calculates the length every time application calls this function. it does not cache inside.
- TODO: do we need to cache the value inside of ndef_message_h
+ TODO: do we need to cache the value inside of ndef_message_s
\par Sync (or) Async: sync
This is a Synchronous API
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_ndef_message_byte_length(ndef_message_h ndef_message, uint32_t *length);
+net_nfc_error_e net_nfc_get_ndef_message_byte_length(
+ ndef_message_s *ndef_message, uint32_t *length);
/**
Append a record to ndef message structure.
This API help to create NDEF message and it control Record flags to follow the NDEF forum specification
@code
net_nfc_error_e result = NET_NFC_OK;
- data_h rawdata;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ data_s *rawdata;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
int idx;
uint8_t * buffer = NULL;
net_nfc_free_ndef_message (msg);
@endcode
-*/
-net_nfc_error_e net_nfc_append_record_to_ndef_message(ndef_message_h ndef_message, ndef_record_h record);
+ */
+net_nfc_error_e net_nfc_append_record_to_ndef_message(
+ ndef_message_s *ndef_message, ndef_record_s *record);
/**
remove the record that indicated by index number.
*/
-net_nfc_error_e net_nfc_remove_record_by_index (ndef_message_h ndef_message, int index);
+net_nfc_error_e net_nfc_remove_record_by_index(ndef_message_s *ndef_message,
+ int index);
/**
get record by index. this function just return the pointer of record.
@exception NET_NFC_OUT_OF_BOUND index is out of bound
*/
-net_nfc_error_e net_nfc_get_record_by_index (ndef_message_h ndef_message, int index, ndef_record_h* record);
+net_nfc_error_e net_nfc_get_record_by_index(ndef_message_s *ndef_message,
+ int index, ndef_record_s **record);
/**
Add a record by index. This API help to add record by index. MB or ME bits will automatically assained.
@exception NET_NFC_INVALID_FORMAT Wrong formatted ndef message
*/
-net_nfc_error_e net_nfc_append_record_by_index (ndef_message_h ndef_message,int index, ndef_record_h record);
+net_nfc_error_e net_nfc_append_record_by_index(ndef_message_s *ndef_message,
+ int index, ndef_record_s *record);
/**
{
date_h type;
int count = 0;
- ndef_message_h ndef = (ndef_message_h)(data);
- ndef_record_h record;
+ ndef_message_s *ndef = (ndef_message_s*)data;
+ ndef_record_s *record;
net_nfc_create_data (&type, "Sp", 2);
net_nfc_search_record_by_type (ndef, NET_NFC_RECORD_WELL_KNOWN_TYPE, type, &record);
}
@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_s *ndef_message,
+ net_nfc_record_tnf_e tnf, data_s *type, ndef_record_s **record);
/**
*/
-net_nfc_error_e net_nfc_free_ndef_message(ndef_message_h ndef_message);
+net_nfc_error_e net_nfc_free_ndef_message(ndef_message_s *ndef_message);
/**
*/
-net_nfc_error_e net_nfc_retrieve_current_ndef_message (ndef_message_h* ndef_message);
+net_nfc_error_e net_nfc_retrieve_current_ndef_message(
+ ndef_message_s **ndef_message);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_NDEF_MESSAGE_H__
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_carrier_config (net_nfc_carrier_config_h * config, net_nfc_conn_handover_carrier_type_e type);
+net_nfc_error_e net_nfc_create_carrier_config(net_nfc_carrier_config_s **config,
+ net_nfc_conn_handover_carrier_type_e type);
/**
Add property key and value for configuration.
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_add_carrier_config_property (net_nfc_carrier_config_h config, uint16_t attribute, uint16_t size, uint8_t * data);
+net_nfc_error_e net_nfc_add_carrier_config_property(
+ net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data);
/**
Remove the key and value from configuration, you can also remove the group withe CREDENTIAL key.
@exception NET_NFC_ALREADY_REGISTERED the given attribute is already registered
*/
-net_nfc_error_e net_nfc_remove_carrier_config_property (net_nfc_carrier_config_h config, uint16_t attribute);
+net_nfc_error_e net_nfc_remove_carrier_config_property(
+ net_nfc_carrier_config_s *config, uint16_t attribute);
/**
Get the property value by attribute.
@exception NET_NFC_NO_DATA_FOUND The given key is not found
*/
-net_nfc_error_e net_nfc_get_carrier_config_property (net_nfc_carrier_config_h config, uint16_t attribute, uint16_t * size, uint8_t ** data);
+net_nfc_error_e net_nfc_get_carrier_config_property(
+ net_nfc_carrier_config_s *config,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data);
/**
The group will be joined into the configure
@exception NET_NFC_ALREADY_REGISTERED The given group is already registered
*/
-net_nfc_error_e net_nfc_append_carrier_config_group (net_nfc_carrier_config_h config, net_nfc_property_group_h group);
+net_nfc_error_e net_nfc_append_carrier_config_group(
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
/**
Remove the group from configure handle
@exception NET_NFC_NO_DATA_FOUND given handle pointer is not exist in the configure handle
*/
-net_nfc_error_e net_nfc_remove_carrier_config_group (net_nfc_carrier_config_h config, net_nfc_property_group_h group);
+net_nfc_error_e net_nfc_remove_carrier_config_group(
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
/**
Get the group from configure handle by index
@exception NET_NFC_NO_DATA_FOUND this is should be happened if the configure handle is dammaged
*/
-net_nfc_error_e net_nfc_get_carrier_config_group (net_nfc_carrier_config_h config, int index, net_nfc_property_group_h * group);
+net_nfc_error_e net_nfc_get_carrier_config_group(
+ net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group);
/**
free the configure handle
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_free_carrier_config (net_nfc_carrier_config_h config);
+net_nfc_error_e net_nfc_free_carrier_config(net_nfc_carrier_config_s *config);
/**
create the group handle
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_carrier_config_group (net_nfc_property_group_h * group, uint16_t attribute);
+net_nfc_error_e net_nfc_create_carrier_config_group (
+ net_nfc_carrier_property_s **group, uint16_t attribute);
/**
add property into the group
@exception NET_NFC_ALREADY_REGISTERED the given key is already registered
*/
-net_nfc_error_e net_nfc_add_carrier_config_group_property (net_nfc_property_group_h group, uint16_t attribute, uint16_t size, uint8_t * data);
+net_nfc_error_e net_nfc_add_carrier_config_group_property(
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t size,
+ uint8_t *data);
/**
get property from group handle
@exception NET_NFC_NO_DATA_FOUND the attribute does not exist in the group
*/
-net_nfc_error_e net_nfc_get_carrier_config_group_property (net_nfc_property_group_h group, uint16_t attribute, uint16_t *size, uint8_t ** data);
+net_nfc_error_e net_nfc_get_carrier_config_group_property(
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data);
/**
remove the property from the group
@exception NET_NFC_NO_DATA_FOUND the attribute does not exist in the group
*/
-net_nfc_error_e net_nfc_remove_carrier_config_group_property (net_nfc_property_group_h group, uint16_t attribute);
+net_nfc_error_e net_nfc_remove_carrier_config_group_property(
+ net_nfc_carrier_property_s *group, uint16_t attribute);
/**
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_free_carrier_group (net_nfc_property_group_h group);
+net_nfc_error_e net_nfc_free_carrier_group(net_nfc_carrier_property_s *group);
/**
Create record handler with config.
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_ndef_record_with_carrier_config (ndef_record_h * record, net_nfc_carrier_config_h config);
+net_nfc_error_e net_nfc_create_ndef_record_with_carrier_config(
+ ndef_record_s **record, net_nfc_carrier_config_s *config);
/**
@exception NET_NFC_INVALID_FORMAT if the record does not contained the valid format.
*/
-net_nfc_error_e net_nfc_create_carrier_config_from_config_record (net_nfc_carrier_config_h* config, ndef_record_h record);
+net_nfc_error_e net_nfc_create_carrier_config_from_config_record(
+ net_nfc_carrier_config_s **config, ndef_record_s *record);
/**
append record into the connection handover request for reponse message;
@exception NET_NFC_INVALID_FORMAT if the record does not contained the valid format.
@exception NET_NFC_NO_DATA_FOUND the attribute does not exist in the group
*/
-net_nfc_error_e net_nfc_append_carrier_config_record (ndef_message_h message, ndef_record_h record, net_nfc_conn_handover_carrier_state_e power_status);
+net_nfc_error_e net_nfc_append_carrier_config_record(ndef_message_s *message,
+ ndef_record_s *record, net_nfc_conn_handover_carrier_state_e power_status);
/**
append record into the connection handover request for reponse message;
@exception NET_NFC_NO_DATA_FOUND Given record does not exist in the ndef message
*/
-net_nfc_error_e net_nfc_remove_carrier_config_record (ndef_message_h message, ndef_record_h record);
+net_nfc_error_e net_nfc_remove_carrier_config_record(ndef_message_s *message,
+ ndef_record_s *record);
/**
get configure record from ndef message by index
@exception NET_NFC_INVALID_FORMAT if the record does not contained the valid format.
*/
-net_nfc_error_e net_nfc_get_carrier_config_record (ndef_message_h message, int index, ndef_record_h * record);
+net_nfc_error_e net_nfc_get_carrier_config_record(ndef_message_s *message,
+ int index, ndef_record_s **record);
/**
get randome number from the connection request message
@exception NET_NFC_INVALID_FORMAT if the record does not contained the valid format.
*/
-net_nfc_error_e net_nfc_get_handover_random_number(ndef_message_h message, unsigned short* random_number);
+net_nfc_error_e net_nfc_get_handover_random_number(ndef_message_s *message,
+ unsigned short *random_number);
/**
get the count of the alternative (configuration) in the message
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
@exception NET_NFC_INVALID_FORMAT if the record does not contained the valid format.
*/
-net_nfc_error_e net_nfc_get_alternative_carrier_record_count (ndef_message_h message, unsigned int * count);
+net_nfc_error_e net_nfc_get_alternative_carrier_record_count(
+ ndef_message_s *message, unsigned int *count);
/**
@exception NET_NFC_OUT_OF_BOUND index number is out of message count
*/
-net_nfc_error_e net_nfc_get_alternative_carrier_power_status (ndef_message_h message, int index, net_nfc_conn_handover_carrier_state_e * power_state);
+net_nfc_error_e net_nfc_get_alternative_carrier_power_status(
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e *power_state);
/**
set power status of the given configruation
@exception NET_NFC_NO_DATA_FOUND there is no alternative record is found
@exception NET_NFC_OUT_OF_BOUND index number is out of message count
*/
-net_nfc_error_e net_nfc_set_alternative_carrier_power_status (ndef_message_h message, int index, net_nfc_conn_handover_carrier_state_e power_status);
+net_nfc_error_e net_nfc_set_alternative_carrier_power_status(
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e power_status);
/**
this function will get carrier type.
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_get_alternative_carrier_type (ndef_message_h message, int index, net_nfc_conn_handover_carrier_type_e * power_state);
-
+net_nfc_error_e net_nfc_get_alternative_carrier_type(
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_type_e *power_state);
/**
craete the connection handover request message
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_handover_request_message (ndef_message_h * message);
+net_nfc_error_e net_nfc_create_handover_request_message(
+ ndef_message_s **message);
/**
craete the connection handover select message
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_handover_select_message (ndef_message_h * message);
+net_nfc_error_e net_nfc_create_handover_select_message(
+ ndef_message_s **message);
/**
craete the connection handover error record message
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
@exception NET_NFC_ALLOC_FAIL allocation is failed
*/
-net_nfc_error_e net_nfc_create_handover_error_record (ndef_record_h * record, uint8_t reason, uint32_t data);
+net_nfc_error_e net_nfc_create_handover_error_record(ndef_record_s **record,
+ uint8_t reason, uint32_t data);
#endif //__NET_NFC_NDEF_MESSAGE_HANDOVER_H__
char uri[] = " yahoo.com";
ndef_record_s uriRecord;
- data_h payload;
+ data_s *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_s **record,
+ net_nfc_record_tnf_e tnf,
+ const data_s *typeName,
+ const data_s *id,
+ const data_s *payload);
/**
this function helps to create text type payload
@code
net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
char* message = "Hello, NFC World";
@endcode
*/
-net_nfc_error_e net_nfc_create_text_type_record(ndef_record_h* record,
+net_nfc_error_e net_nfc_create_text_type_record(ndef_record_s **record,
const char* text, const char* language_code_str, net_nfc_encode_type_e encode);
/**
@code
net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
net_nfc_create_ndef_message (&msg);
net_nfc_create_uri_type_record (&record ,"http://www.samsung.com" ,NET_NFC_SCHEMA_FULL_URI);
@endcode
*/
-net_nfc_error_e net_nfc_create_uri_type_record(ndef_record_h* record,
+net_nfc_error_e net_nfc_create_uri_type_record(ndef_record_s **record,
const char *uri, net_nfc_schema_type_e protocol_schema);
/**
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 data_s* 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_s *record,
+ data_s **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_s *record, data_s **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_s *record, data_s **id);
/**
this function is getter of record TNF value.
*/
-net_nfc_error_e net_nfc_get_record_tnf(ndef_record_h record,
+net_nfc_error_e net_nfc_get_record_tnf(ndef_record_s *record,
net_nfc_record_tnf_e *tnf);
/**
@code
- ndef_record_h record;
+ ndef_record_s *record;
uint8_t flag;
net_nfc_get_record_by_index (msg, 0, &record);
@endcode
*/
-net_nfc_error_e net_nfc_get_record_flags (ndef_record_h record, uint8_t * flag);
+net_nfc_error_e net_nfc_get_record_flags(ndef_record_s *record, uint8_t *flag);
/**
@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_s *record, data_s *id);
/**
this function free the record handler. do not use this function after appending the ndef message
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_free_record (ndef_record_h record);
+net_nfc_error_e net_nfc_free_record(ndef_record_s *record);
/**
*/
net_nfc_error_e net_nfc_create_text_string_from_text_record(
- ndef_record_h record, char** buffer);
+ ndef_record_s *record, char **buffer);
/**
this function get language code from text record. (ex: US-en)
*/
net_nfc_error_e net_nfc_get_languange_code_string_from_text_record(
- ndef_record_h record, char** lang_code_str);
+ ndef_record_s *record, char **lang_code_str);
/**
*/
net_nfc_error_e net_nfc_get_encoding_type_from_text_record(
- ndef_record_h record, net_nfc_encode_type_e * encoding);
+ ndef_record_s *record, net_nfc_encode_type_e *encoding);
/**
*/
net_nfc_error_e net_nfc_create_uri_string_from_uri_record(
- ndef_record_h record, char ** uri);
+ ndef_record_s *record, char **uri);
#endif //__NET_NFC_NDEF_RECORD_H__
@exception NET_NFC_ALLOC_FAIL memory allocation is failed
@code
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
// create a ndef message and add some records
// ...
net_nfc_sign_records(msg, 0, 1, "/tmp/cert.p12", "abcdef");
@endcode
*/
-net_nfc_error_e net_nfc_sign_records(ndef_message_h msg, int begin_index,
+net_nfc_error_e net_nfc_sign_records(ndef_message_s *msg, int begin_index,
int end_index, char *cert_file, char *password);
/**
@exception NET_NFC_ALLOC_FAIL memory allocation is failed
@code
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
// create a ndef message and add some records
// ...
net_nfc_sign_ndef_message(msg, "/tmp/cert.p12", "abcdef");
@endcode
*/
-net_nfc_error_e net_nfc_sign_ndef_message(ndef_message_h msg, char *cert_file,
+net_nfc_error_e net_nfc_sign_ndef_message(ndef_message_s *msg, char *cert_file,
char *password);
/**
@code
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h begin_record = NULL;
- ndef_record_h sign_record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *begin_record = NULL;
+ ndef_record_s *sign_record = NULL;
// import NDEF message including the signature record.
// ...
return (error == NET_NFC_OK);
@endcode
*/
-net_nfc_error_e net_nfc_verify_signature_records(ndef_record_h begin_record,
- ndef_record_h sign_record);
+net_nfc_error_e net_nfc_verify_signature_records(ndef_record_s *begin_record,
+ ndef_record_s *sign_record);
/**
This function does verify signature in NDEF message
@code
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
// import NDEF message including the signature record.
// ...
return (error == NET_NFC_OK);
@endcode
*/
-net_nfc_error_e net_nfc_verify_signature_ndef_message(ndef_message_h msg);
+net_nfc_error_e net_nfc_verify_signature_ndef_message(ndef_message_s *msg);
#endif //__NET_NFC_SIGN_RECORD_H__
*/
-net_nfc_error_e net_nfc_get_tag_type(net_nfc_target_info_h target_info,
+net_nfc_error_e net_nfc_get_tag_type(net_nfc_target_info_s *target_info,
net_nfc_target_type_e *type);
/**
*/
-net_nfc_error_e net_nfc_get_tag_handle(net_nfc_target_info_h target_info,
- net_nfc_target_handle_h *handle);
+net_nfc_error_e net_nfc_get_tag_handle(net_nfc_target_info_s *target_info,
+ net_nfc_target_handle_s **handle);
/**
this API returns the NDEF support boolean value.
*/
-net_nfc_error_e net_nfc_get_tag_ndef_support(net_nfc_target_info_h target_info,
+net_nfc_error_e net_nfc_get_tag_ndef_support(net_nfc_target_info_s *target_info,
bool *is_support);
/**
*/
-net_nfc_error_e net_nfc_get_tag_max_data_size(net_nfc_target_info_h target_info,
+net_nfc_error_e net_nfc_get_tag_max_data_size(net_nfc_target_info_s *target_info,
uint32_t *max_size);
/**
*/
net_nfc_error_e net_nfc_get_tag_actual_data_size(
- net_nfc_target_info_h target_info, uint32_t *actual_data);
+ net_nfc_target_info_s *target_info, uint32_t *actual_data);
/**
case NET_NFC_MESSAGE_TAG_DISCOVERED:
if(info != NULL)
{
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
char **keys;
int keys_length;
*/
-net_nfc_error_e net_nfc_get_tag_info_keys(net_nfc_target_info_h target_info,
+net_nfc_error_e net_nfc_get_tag_info_keys(net_nfc_target_info_s *target_info,
char ***keys, int *number_of_keys);
/**
case NET_NFC_MESSAGE_TAG_DISCOVERED:
if(info != NULL)
{
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
char** keys;
int keys_length;
for(; index < keys_length; index++)
{
char* key = keys[index];
- data_h value;
+ data_s *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_s *target_info,
+ const char *key, data_s **value);
/**
Duplicate a handle of target information
- ** IMPORTANT : After using duplicated handle, you should release a handle returned from this function.
- ** You can release a handle by net_nfc_release_tag_info function.
+ ** IMPORTANT : After using duplicated handle, you should release a handle returned from this function.
+ ** You can release a handle by net_nfc_release_tag_info function.
- \par Sync (or) Async: Sync
- This is a Synchronous API
+ \par Sync (or) Async: Sync
+ This is a Synchronous API
- @param[in] origin The original handle you want to duplicate
- @param[out] result The result of this function.
+ @param[in] origin The original handle you want to duplicate
+ @param[out] result The result of this function.
- @code
+ @code
void user_cb(net_nfc_message_e message, net_nfc_error_e result, void *data, void *trans_param)
{
switch(message)
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
- net_nfc_target_info_h handle = NULL;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
+ net_nfc_target_info_s *handle = NULL;
net_nfc_duplicate_target_info(target_info, &handle);
break;
}
}
- @endcode
-
- @return return the result of calling this functions
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
+ @endcode
+ @return return the result of calling this functions
+ @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_duplicate_target_info(net_nfc_target_info_h origin,
- net_nfc_target_info_h *result);
+net_nfc_error_e net_nfc_duplicate_target_info(net_nfc_target_info_s *origin,
+ net_nfc_target_info_s **result);
/**
- After using net_nfc_target_info_h handle, you should release its resource by this function.
+ After using net_nfc_target_info_s *handle, you should release its resource by this function.
- ** IMPORTANT : Never use this function in user callback you registered by net_nfc_set_response_callback function
- ** This function is for the result of net_nfc_duplicate_target_info or net_nfc_get_current_tag_info_sync
+ ** IMPORTANT : Never use this function in user callback you registered by net_nfc_set_response_callback function
+ ** This function is for the result of net_nfc_duplicate_target_info or net_nfc_get_current_tag_info_sync
- \par Sync (or) Async: Sync
- This is a Synchronous API
+ \par Sync (or) Async: Sync
+ This is a Synchronous API
- @param[in] target_info target info handle
+ @param[in] target_info target info handle
- @code
- net_nfc_target_info_h handle;
+ @code
+ net_nfc_target_info_s *handle;
net_nfc_get_current_tag_info_sync(&handle);
// do something...
net_nfc_release_tag_info(handle);
- @endcode
+ @endcode
- @return return the result of calling this functions
+ @return return the result of calling this functions
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
+ @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
*/
-net_nfc_error_e net_nfc_release_tag_info(net_nfc_target_info_h target_info);
+net_nfc_error_e net_nfc_release_tag_info(net_nfc_target_info_s *target_info);
/**
-@}
-*/
+ @}
+ */
#endif //__NET_NFC_TARGET_INFO_H__
#include "net_nfc_typedef_internal.h"
#include "net_nfc_util_internal.h"
-API net_nfc_error_e net_nfc_create_data_only(data_h* data)
+API net_nfc_error_e net_nfc_create_data_only(data_s **data)
{
return net_nfc_create_data(data, NULL, 0);
}
-API net_nfc_error_e net_nfc_create_data(data_h *data,
- const uint8_t *bytes, size_t length)
+API net_nfc_error_e net_nfc_create_data(data_s **data, const uint8_t *bytes,
+ const size_t length)
{
data_s *tmp_data = NULL;
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
- *data = NULL;
-
_net_nfc_util_alloc_mem(tmp_data, sizeof(data_s));
if (tmp_data == NULL)
return NET_NFC_ALLOC_FAIL;
}
}
- *data = (data_h)tmp_data;
+ *data = tmp_data;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_get_data(const data_h data,
- uint8_t **bytes, size_t *length)
+API net_nfc_error_e net_nfc_get_data(const data_s *data, uint8_t **bytes,
+ size_t *length)
{
- data_s *tmp_data = (data_s *)data;
-
- if (bytes == NULL || length == NULL)
- return NET_NFC_NULL_PARAMETER;
-
- *bytes = NULL;
- *length = 0;
-
- if (data == NULL)
+ if (bytes == NULL || length == NULL || NULL == data)
return NET_NFC_NULL_PARAMETER;
- *bytes = tmp_data->buffer;
- *length = tmp_data->length;
+ *bytes = data->buffer;
+ *length = data->length;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_set_data(data_h data,
- const uint8_t *bytes, size_t length)
+API net_nfc_error_e net_nfc_set_data(data_s *data, const uint8_t *bytes, const size_t length)
{
- data_s *tmp_data = (data_s *)data;
-
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
- if (tmp_data->buffer == bytes && tmp_data->length == length)
+ if (data->buffer == bytes && data->length == length)
return NET_NFC_OK;
- if (tmp_data->buffer != NULL)
- _net_nfc_util_free_mem(tmp_data->buffer);
+ if (data->buffer)
+ _net_nfc_util_free_mem(data->buffer);
if (length <= 0)
{
- tmp_data->buffer = NULL;
- tmp_data->length = 0;
+ data->buffer = NULL;
+ data->length = 0;
return NET_NFC_OK;
}
- if (length > 0)
- _net_nfc_util_alloc_mem((tmp_data)->buffer, length);
+ if (0 < length)
+ _net_nfc_util_alloc_mem(data->buffer, length);
- if (bytes != NULL)
- memcpy(tmp_data->buffer, bytes, length);
+ if (bytes)
+ memcpy(data->buffer, bytes, length);
- tmp_data->length = length;
+ data->length = length;
return NET_NFC_OK;
}
-API size_t net_nfc_get_data_length(const data_h data)
+API size_t net_nfc_get_data_length(const data_s *data)
{
- data_s *tmp_data = (data_s *)data;
-
if (data == NULL)
return 0;
- return tmp_data->length;
+ return data->length;
}
-API uint8_t* net_nfc_get_data_buffer(const data_h data)
+API uint8_t* net_nfc_get_data_buffer(const data_s *data)
{
- data_s *tmp_data = (data_s *)data;
-
if (data == NULL)
return NULL;
- return tmp_data->buffer;
+ return data->buffer;
}
-API net_nfc_error_e net_nfc_free_data(data_h data)
+API net_nfc_error_e net_nfc_free_data(data_s *data)
{
- data_s *tmp_data = (data_s *)data;
-
if (data == NULL)
return NET_NFC_NULL_PARAMETER;
- if (tmp_data->buffer != NULL)
- _net_nfc_util_free_mem(tmp_data->buffer);
+ if (data->buffer != NULL)
+ _net_nfc_util_free_mem(data->buffer);
- _net_nfc_util_free_mem(tmp_data);
+ _net_nfc_util_free_mem(data);
return NET_NFC_OK;
-}
+}
\ No newline at end of file
static void p2p_connection_handover(GObject *source_object,
GAsyncResult *res,
- gpointer user_data);
-
-static void p2p_connection_handover(GObject *source_object,
- GAsyncResult *res,
gpointer user_data)
{
NetNfcCallback *func_data = (NetNfcCallback *)user_data;
API net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle)
+ net_nfc_connection_handover_info_s *info)
{
- net_nfc_connection_handover_info_s *info =
- (net_nfc_connection_handover_info_s *)info_handle;
-
- if (info_handle == NULL)
+ if (info == NULL)
return NET_NFC_NULL_PARAMETER;
if (info->data.buffer != NULL)
API net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_type(
- net_nfc_connection_handover_info_h info_handle,
+ net_nfc_connection_handover_info_s *info,
net_nfc_conn_handover_carrier_type_e *type)
{
- net_nfc_connection_handover_info_s *info =
- (net_nfc_connection_handover_info_s *)info_handle;
-
- if (info_handle == NULL || type == NULL)
+ if (info == NULL || type == NULL)
return NET_NFC_NULL_PARAMETER;
*type = info->type;
}
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_connection_handover_info_s *info, data_s **data)
{
- net_nfc_connection_handover_info_s *info =
- (net_nfc_connection_handover_info_s *)info_handle;
-
- if (info_handle == NULL || data == NULL)
+ if (info == NULL || data == NULL)
return NET_NFC_NULL_PARAMETER;
return net_nfc_create_data(data, info->data.buffer, info->data.length);
API net_nfc_error_e net_nfc_client_p2p_connection_handover(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_p2p_connection_handover_completed_cb callback,
void *cb_data)
API net_nfc_error_e net_nfc_client_p2p_connection_handover_sync(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_conn_handover_carrier_type_e arg_type,
net_nfc_conn_handover_carrier_type_e *out_carrier,
- data_h *out_ac_data)
+ data_s **out_ac_data)
{
GVariant *out_data = NULL;
net_nfc_error_e out_result = NET_NFC_OK;
/* Public APIs */
-API net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config,
+API net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_s *config,
net_nfc_client_llcp_config_completed callback, void *user_data)
{
GVariant *var;
}
API net_nfc_error_e net_nfc_client_llcp_config_sync(
- net_nfc_llcp_config_info_h config)
+ net_nfc_llcp_config_info_s *config)
{
gboolean ret;
GVariant *var = NULL;
}
API net_nfc_error_e net_nfc_client_llcp_get_config(
- net_nfc_llcp_config_info_h *config)
+ net_nfc_llcp_config_info_s **config)
{
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
- *config = (net_nfc_llcp_config_info_h)&llcp_config;
+ *config = &llcp_config;
return NET_NFC_OK;
}
}
API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
- const char *service_name,
- net_nfc_llcp_socket_t *out_socket)
+ const char *service_name, net_nfc_llcp_socket_t *out_socket)
{
gboolean ret;
GError *error = NULL;
}
API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
- data_h data, net_nfc_client_llcp_send_completed callback, void *user_data)
+ data_s *data, net_nfc_client_llcp_send_completed callback, void *user_data)
{
GVariant *variant;
LlcpFuncData *func_data;
}
API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
- data_h data)
+ data_s *data)
{
gboolean ret;
GVariant *variant;
API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
sap_t sap,
- data_h data,
+ data_s *data,
net_nfc_client_llcp_send_to_completed callback,
void *user_data)
{
}
API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
- sap_t sap, data_h data)
+ sap_t sap, data_s *data)
{
gboolean ret;
GVariant *variant;
}
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)
+ size_t request_length, data_s **out_data)
{
gboolean ret;
GVariant *variant;
net_nfc_llcp_socket_t socket,
size_t request_length,
sap_t *out_sap,
- data_h *out_data)
+ data_s **out_data)
{
sap_t sap;
gboolean ret;
}
API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
- net_nfc_llcp_socket_option_h option)
+ net_nfc_llcp_socket_option_s *option)
{
net_nfc_llcp_internal_socket_s *socket_data = NULL;
{
socket_data->miu = 128;
socket_data->rw = 1;
- socket_data->type =
- NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
+ socket_data->type = NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED;
}
socket_data->device_id = llcp_handle;
API net_nfc_error_e net_nfc_client_llcp_get_local_config(
- net_nfc_llcp_config_info_h *config)
+ net_nfc_llcp_config_info_s **config)
{
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
- *config = (net_nfc_llcp_config_info_h)&llcp_config;
+ *config = &llcp_config;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
- net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_h *info)
+ net_nfc_llcp_socket_t socket, net_nfc_llcp_socket_option_s **info)
{
net_nfc_llcp_internal_socket_s *socket_data = NULL;
if (socket_data == NULL)
return NET_NFC_LLCP_INVALID_SOCKET;
- *info = (net_nfc_llcp_socket_option_h)socket_data;
+ *info = (net_nfc_llcp_socket_option_s*)socket_data;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
- net_nfc_llcp_socket_option_h *option,
+ net_nfc_llcp_socket_option_s **option,
uint16_t miu,
uint8_t rw,
net_nfc_socket_type_e type)
{
- net_nfc_llcp_socket_option_s *struct_option = NULL;
+ net_nfc_llcp_socket_option_s *tmp_option = NULL;
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
RETVM_IF(miu < 128 || miu > 1152, NET_NFC_OUT_OF_BOUND, "miu = %d", miu);
NET_NFC_OUT_OF_BOUND,
"type = %d", type);
- _net_nfc_util_alloc_mem(struct_option, sizeof(net_nfc_llcp_socket_option_s));
- if (struct_option != NULL)
+ _net_nfc_util_alloc_mem(tmp_option, sizeof(net_nfc_llcp_socket_option_s));
+ if (tmp_option != NULL)
{
- struct_option->miu = miu;
- struct_option->rw = rw;
- struct_option->type = type;
+ tmp_option->miu = miu;
+ tmp_option->rw = rw;
+ tmp_option->type = type;
- *option = (net_nfc_llcp_socket_option_h)struct_option;
+ *option = tmp_option;
return NET_NFC_OK;
}
}
API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
- net_nfc_llcp_socket_option_h *option)
+ net_nfc_llcp_socket_option_s **option)
{
return net_nfc_client_llcp_create_socket_option(option, 128, 1,
NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
}
API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
- net_nfc_llcp_socket_option_h option, uint16_t *miu)
+ net_nfc_llcp_socket_option_s *option, uint16_t *miu)
{
- net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s*)option;
-
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == miu, NET_NFC_NULL_PARAMETER);
- *miu = struct_option->miu;
+ *miu = option->miu;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
- net_nfc_llcp_socket_option_h option, uint16_t miu)
+ net_nfc_llcp_socket_option_s *option, uint16_t miu)
{
- net_nfc_llcp_socket_option_s *struct_option =
- (net_nfc_llcp_socket_option_s *)option;
-
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
- struct_option->miu = miu;
+ option->miu = miu;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
- net_nfc_llcp_socket_option_h option, uint8_t *rw)
+ net_nfc_llcp_socket_option_s *option, uint8_t *rw)
{
- net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s*)option;
-
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == rw, NET_NFC_NULL_PARAMETER);
- *rw = struct_option->rw;
+ *rw = option->rw;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
- net_nfc_llcp_socket_option_h option, uint8_t rw)
+ net_nfc_llcp_socket_option_s *option, uint8_t rw)
{
- net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s*)option;
-
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
- struct_option->rw = rw;
+ option->rw = rw;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
- net_nfc_llcp_socket_option_h option, net_nfc_socket_type_e *type)
+ net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e *type)
{
- net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s*)option;
-
RETV_IF(NULL == type, NET_NFC_NULL_PARAMETER);
- *type = struct_option->type;
+ *type = option->type;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
- net_nfc_llcp_socket_option_h option, net_nfc_socket_type_e type)
+ net_nfc_llcp_socket_option_s *option, net_nfc_socket_type_e type)
{
- net_nfc_llcp_socket_option_s *struct_option = (net_nfc_llcp_socket_option_s*)option;
-
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
- struct_option->type = type;
+ option->type = type;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
- net_nfc_llcp_socket_option_h option)
+ net_nfc_llcp_socket_option_s *option)
{
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
_net_nfc_util_free_mem(option);
-
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_create_config(
- net_nfc_llcp_config_info_h *config,
+ net_nfc_llcp_config_info_s **config,
uint16_t miu,
uint16_t wks,
uint8_t lto,
tmp_config->lto = lto;
tmp_config->option = option;
- *config = (net_nfc_llcp_config_info_h)tmp_config;
+ *config = tmp_config;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_create_config_default(
- net_nfc_llcp_config_info_h *config)
+ net_nfc_llcp_config_info_s **config)
{
return net_nfc_client_llcp_create_config(config, 128, 1, 10, 0);
}
API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
- net_nfc_llcp_config_info_h config, uint16_t *miu)
+ net_nfc_llcp_config_info_s *config, uint16_t *miu)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == miu, NET_NFC_NULL_PARAMETER);
- *miu = tmp_config->miu;
-
+ *miu = config->miu;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
- net_nfc_llcp_config_info_h config, uint16_t *wks)
+ net_nfc_llcp_config_info_s *config, uint16_t *wks)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == wks, NET_NFC_NULL_PARAMETER);
- *wks = tmp_config->wks;
-
+ *wks = config->wks;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
- net_nfc_llcp_config_info_h config, uint8_t *lto)
+ net_nfc_llcp_config_info_s *config, uint8_t *lto)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == lto, NET_NFC_NULL_PARAMETER);
- *lto = tmp_config->lto;
-
+ *lto = config->lto;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_get_config_option(
- net_nfc_llcp_config_info_h config, uint8_t *option)
+ net_nfc_llcp_config_info_s *config, uint8_t *option)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
RETV_IF(NULL == option, NET_NFC_NULL_PARAMETER);
- *option = tmp_config->option;
-
+ *option = config->option;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
- net_nfc_llcp_config_info_h config, uint16_t miu)
+ net_nfc_llcp_config_info_s *config, uint16_t miu)
{
- net_nfc_llcp_config_info_s * tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
RETVM_IF(miu < 128 || miu > 1152, NET_NFC_OUT_OF_BOUND, "miu = %d", miu);
- tmp_config->miu = miu;
+ config->miu = miu;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
- net_nfc_llcp_config_info_h config, uint16_t wks)
+ net_nfc_llcp_config_info_s *config, uint16_t wks)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
- tmp_config->wks = wks;
+ config->wks = wks;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
- net_nfc_llcp_config_info_h config, uint8_t lto)
+ net_nfc_llcp_config_info_s *config, uint8_t lto)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
- tmp_config->lto = lto;
+ config->lto = lto;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_set_config_option(
- net_nfc_llcp_config_info_h config, uint8_t option)
+ net_nfc_llcp_config_info_s *config, uint8_t option)
{
- net_nfc_llcp_config_info_s *tmp_config = (net_nfc_llcp_config_info_s*)config;
-
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
- tmp_config->option = option;
+ config->option = option;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_client_llcp_free_config(
- net_nfc_llcp_config_info_h config)
+ net_nfc_llcp_config_info_s *config)
{
RETV_IF(NULL == config, NET_NFC_NULL_PARAMETER);
static NetNfcGDbusNdef *ndef_proxy = NULL;
-
static gboolean ndef_is_supported_tag(void);
-static void ndef_call_read(GObject *source_object,
- GAsyncResult *res,
+static void ndef_call_read(GObject *source_object, GAsyncResult *res,
gpointer user_data);
-static void ndef_call_write(GObject *source_object,
- GAsyncResult *res,
+static void ndef_call_write(GObject *source_object, GAsyncResult *res,
gpointer user_data);
-static void ndef_call_make_read_only(GObject *source_object,
- GAsyncResult *res,
+static void ndef_call_make_read_only(GObject *source_object, GAsyncResult *res,
gpointer user_data);
-static void ndef_call_format(GObject *source_object,
- GAsyncResult *res,
+static void ndef_call_format(GObject *source_object, GAsyncResult *res,
gpointer user_data);
static gboolean ndef_is_supported_tag(void)
{
net_nfc_client_ndef_read_completed callback =
(net_nfc_client_ndef_read_completed)func_data->callback;
- ndef_message_h message;
+ ndef_message_s *message;
message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
g_free(func_data);
}
-API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_s *handle,
net_nfc_client_ndef_read_completed callback, void *user_data)
{
NetNfcCallback *func_data;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle,
- ndef_message_h *message)
+API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_s *handle,
+ ndef_message_s **message)
{
net_nfc_error_e out_result = NET_NFC_OK;
GVariant *out_data = NULL;
return out_result;
}
-API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle,
- ndef_message_h message,
+API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_s *handle,
+ ndef_message_s *message,
net_nfc_client_ndef_write_completed callback,
void *user_data)
{
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handle,
- ndef_message_h message)
+API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_s *handle,
+ ndef_message_s *message)
{
net_nfc_error_e out_result = NET_NFC_OK;
GError *error = NULL;
}
API net_nfc_error_e net_nfc_client_ndef_make_read_only(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
net_nfc_client_ndef_make_read_only_completed callback,
void *user_data)
{
}
API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync(
- net_nfc_target_handle_h handle)
+ net_nfc_target_handle_s *handle)
{
net_nfc_error_e out_result = NET_NFC_OK;
GError *error = NULL;
return out_result;
}
-API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
- data_h key, net_nfc_client_ndef_format_completed callback, void *user_data)
+API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_s *handle,
+ data_s *key, net_nfc_client_ndef_format_completed callback, void *user_data)
{
NetNfcCallback *func_data;
GVariant *arg_data;
}
API net_nfc_error_e net_nfc_client_ndef_format_sync(
- net_nfc_target_handle_h handle, data_h key)
+ net_nfc_target_handle_s *handle, data_s *key)
{
net_nfc_error_e out_result = NET_NFC_OK;
GVariant *arg_data;
}
/* prevent executing daemon when nfc is off */
- if (net_nfc_client_manager_is_activated() == false) {
+ if (net_nfc_client_manager_is_activated() == false)
return NET_NFC_INVALID_STATE;
- }
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_NOT_CONNECTED;
/* public functions */
-API net_nfc_error_e net_nfc_create_ndef_message(ndef_message_h *ndef_message)
+API net_nfc_error_e net_nfc_create_ndef_message(ndef_message_s **ndef_message)
{
- return net_nfc_util_create_ndef_message((ndef_message_s **)ndef_message);
+ return net_nfc_util_create_ndef_message(ndef_message);
}
API net_nfc_error_e net_nfc_create_rawdata_from_ndef_message(
- ndef_message_h ndef_message, data_h *rawdata)
+ ndef_message_s *ndef_message, data_s **rawdata)
{
uint32_t count;
net_nfc_error_e result;
- data_h data;
+ data_s *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);
+ result = net_nfc_util_convert_ndef_message_to_rawdata(ndef_message, data);
+
if (result == NET_NFC_OK)
*rawdata = data;
else
}
API net_nfc_error_e net_nfc_create_ndef_message_from_rawdata(
- ndef_message_h *ndef_message, data_h rawdata)
+ ndef_message_s **ndef_message, data_s *rawdata)
{
net_nfc_error_e result;
- ndef_message_h msg;
+ ndef_message_s *msg;
if (ndef_message == NULL || rawdata == NULL)
return NET_NFC_NULL_PARAMETER;
if (result != NET_NFC_OK)
return result;
- result = net_nfc_util_convert_rawdata_to_ndef_message(
- (data_s *)rawdata, (ndef_message_s *)msg);
+ result = net_nfc_util_convert_rawdata_to_ndef_message(rawdata, msg);
if (result == NET_NFC_OK)
*ndef_message = msg;
else
}
API net_nfc_error_e net_nfc_get_ndef_message_byte_length(
- ndef_message_h ndef_message, uint32_t *length)
+ ndef_message_s *ndef_message, uint32_t *length)
{
net_nfc_error_e result;
if (ndef_message == NULL || length == NULL)
return NET_NFC_NULL_PARAMETER;
- *length = net_nfc_util_get_ndef_message_length((ndef_message_s *)ndef_message);
+ *length = net_nfc_util_get_ndef_message_length(ndef_message);
if (*length > 0)
result = NET_NFC_OK;
else
}
API net_nfc_error_e net_nfc_append_record_to_ndef_message(
- ndef_message_h ndef_message, ndef_record_h record)
+ ndef_message_s *ndef_message, ndef_record_s *record)
{
if (ndef_message == NULL || record == NULL)
return NET_NFC_NULL_PARAMETER;
- return net_nfc_util_append_record((ndef_message_s*)ndef_message, (ndef_record_s *)record);
+ return net_nfc_util_append_record(ndef_message, record);
}
-API net_nfc_error_e net_nfc_free_ndef_message(ndef_message_h ndef_message)
+API net_nfc_error_e net_nfc_free_ndef_message(ndef_message_s *ndef_message)
{
if (ndef_message == NULL)
return NET_NFC_NULL_PARAMETER;
- return net_nfc_util_free_ndef_message((ndef_message_s *)ndef_message);
+ return net_nfc_util_free_ndef_message(ndef_message);
}
API net_nfc_error_e net_nfc_get_ndef_message_record_count(
- ndef_message_h ndef_message, int *count)
+ ndef_message_s *ndef_message, int *count)
{
- ndef_message_s *msg = (ndef_message_s *)ndef_message;
-
if (ndef_message == NULL || count == NULL)
return NET_NFC_NULL_PARAMETER;
- *count = msg->recordCount;
-
+ *count = ndef_message->recordCount;
return NET_NFC_OK;
}
-API void net_nfc_ndef_print_message (ndef_message_h ndef_message )
+API void net_nfc_ndef_print_message (ndef_message_s *ndef_message)
{
- net_nfc_util_print_ndef_message((ndef_message_s *)(ndef_message));
+ net_nfc_util_print_ndef_message(ndef_message);
}
-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)
+API net_nfc_error_e net_nfc_search_record_by_type(ndef_message_s *ndef_message,
+ net_nfc_record_tnf_e tnf, data_s *type, ndef_record_s **record)
{
- return net_nfc_util_search_record_by_type ((ndef_message_s*)ndef_message, tnf, (data_s *)type, (ndef_record_s**)record);
+ return net_nfc_util_search_record_by_type(ndef_message, tnf, type, record);
}
-API net_nfc_error_e net_nfc_append_record_by_index (ndef_message_h ndef_message,
- int index, ndef_record_h record)
+API net_nfc_error_e net_nfc_append_record_by_index(ndef_message_s *ndef_message,
+ int index, ndef_record_s *record)
{
- return net_nfc_util_append_record_by_index ((ndef_message_s *) ndef_message, index, (ndef_record_s *) record);
+ return net_nfc_util_append_record_by_index(ndef_message, index, record);
}
-API net_nfc_error_e net_nfc_get_record_by_index (ndef_message_h ndef_message,
- int index, ndef_record_h* record)
+API net_nfc_error_e net_nfc_get_record_by_index (ndef_message_s *ndef_message,
+ int index, ndef_record_s **record)
{
- return net_nfc_util_get_record_by_index ((ndef_message_s*) ndef_message, index, (ndef_record_s**) record);
+ return net_nfc_util_get_record_by_index(ndef_message, index, record);
}
-API net_nfc_error_e net_nfc_remove_record_by_index (ndef_message_h ndef_message,
+API net_nfc_error_e net_nfc_remove_record_by_index(ndef_message_s *ndef_message,
int index)
{
- return net_nfc_util_remove_record_by_index ((ndef_message_s*)ndef_message, index);
+ return net_nfc_util_remove_record_by_index(ndef_message, index);
}
API net_nfc_error_e net_nfc_retrieve_current_ndef_message(
- ndef_message_h* ndef_message)
+ ndef_message_s **ndef_message)
{
net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
char file_path[PATH_MAX] = { 0, };
#include "net_nfc_util_handover.h"
API net_nfc_error_e net_nfc_create_carrier_config(
- net_nfc_carrier_config_h *config, net_nfc_conn_handover_carrier_type_e type)
+ net_nfc_carrier_config_s **config, net_nfc_conn_handover_carrier_type_e type)
{
- return net_nfc_util_create_carrier_config ((net_nfc_carrier_config_s **)config, type);
+ return net_nfc_util_create_carrier_config(config, type);
}
API net_nfc_error_e net_nfc_add_carrier_config_property(
- net_nfc_carrier_config_h config, uint16_t attribute, uint16_t size, uint8_t *data)
+ net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data)
{
- return net_nfc_util_add_carrier_config_property((net_nfc_carrier_config_s *) config, attribute, size, data);
+ return net_nfc_util_add_carrier_config_property(config, attribute, size, data);
}
API net_nfc_error_e net_nfc_remove_carrier_config_property(
- net_nfc_carrier_config_h config, uint16_t attribute)
+ net_nfc_carrier_config_s *config, uint16_t attribute)
{
- return net_nfc_util_remove_carrier_config_property((net_nfc_carrier_config_s *) config, attribute);
+ return net_nfc_util_remove_carrier_config_property(config, attribute);
}
API net_nfc_error_e net_nfc_get_carrier_config_property(
- net_nfc_carrier_config_h config, uint16_t attribute, uint16_t * size, uint8_t ** data)
+ net_nfc_carrier_config_s *config,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data)
{
- return net_nfc_util_get_carrier_config_property((net_nfc_carrier_config_s *) config, attribute, size, data);
+ return net_nfc_util_get_carrier_config_property(config, attribute, size, data);
}
API net_nfc_error_e net_nfc_append_carrier_config_group(
- net_nfc_carrier_config_h config, net_nfc_property_group_h group)
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
{
- return net_nfc_util_append_carrier_config_group((net_nfc_carrier_config_s *) config, (net_nfc_carrier_property_s *) group);
+ return net_nfc_util_append_carrier_config_group(config, group);
}
API net_nfc_error_e net_nfc_remove_carrier_config_group(
- net_nfc_carrier_config_h config, net_nfc_property_group_h group)
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
{
- return net_nfc_util_remove_carrier_config_group((net_nfc_carrier_config_s *) config, (net_nfc_carrier_property_s *) group);
+ return net_nfc_util_remove_carrier_config_group(config, group);
}
API net_nfc_error_e net_nfc_get_carrier_config_group(
- net_nfc_carrier_config_h config, int index, net_nfc_property_group_h * group)
+ net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group)
{
- return net_nfc_util_get_carrier_config_group((net_nfc_carrier_config_s *) config, index, (net_nfc_carrier_property_s **) group);
+ return net_nfc_util_get_carrier_config_group(config, index, group);
}
-API net_nfc_error_e net_nfc_free_carrier_config(net_nfc_carrier_config_h config)
+API net_nfc_error_e net_nfc_free_carrier_config(net_nfc_carrier_config_s *config)
{
- return net_nfc_util_free_carrier_config((net_nfc_carrier_config_s *) config);
+ return net_nfc_util_free_carrier_config(config);
}
API net_nfc_error_e net_nfc_create_carrier_config_group(
- net_nfc_property_group_h * group, uint16_t attribute)
+ net_nfc_carrier_property_s **group, uint16_t attribute)
{
- return net_nfc_util_create_carrier_config_group((net_nfc_carrier_property_s **) group, attribute);
+ return net_nfc_util_create_carrier_config_group(group, attribute);
}
API net_nfc_error_e net_nfc_add_carrier_config_group_property(
- net_nfc_property_group_h group, uint16_t attribute, uint16_t size, uint8_t * data)
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t size,
+ uint8_t *data)
{
- return net_nfc_util_add_carrier_config_group_property((net_nfc_carrier_property_s*) group, attribute, size, data);
+ return net_nfc_util_add_carrier_config_group_property(group, attribute, size, data);
}
API net_nfc_error_e net_nfc_get_carrier_config_group_property(
- net_nfc_property_group_h group, uint16_t attribute, uint16_t *size, uint8_t ** data)
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data)
{
- return net_nfc_util_get_carrier_config_group_property((net_nfc_carrier_property_s*) group, attribute, size, data);
+ return net_nfc_util_get_carrier_config_group_property(group, attribute, size, data);
}
API net_nfc_error_e net_nfc_remove_carrier_config_group_property(
- net_nfc_property_group_h group, uint16_t attribute)
+ net_nfc_carrier_property_s *group, uint16_t attribute)
{
- return net_nfc_util_remove_carrier_config_group_property((net_nfc_carrier_property_s*) group, attribute);
+ return net_nfc_util_remove_carrier_config_group_property(group, attribute);
}
-API net_nfc_error_e net_nfc_free_carrier_group(net_nfc_property_group_h group)
+API net_nfc_error_e net_nfc_free_carrier_group(net_nfc_carrier_property_s *group)
{
- return net_nfc_util_free_carrier_group((net_nfc_carrier_property_s*) group);
+ return net_nfc_util_free_carrier_group(group);
}
API net_nfc_error_e net_nfc_create_ndef_record_with_carrier_config(
- ndef_record_h * record, net_nfc_carrier_config_h config)
+ ndef_record_s **record, net_nfc_carrier_config_s *config)
{
- return net_nfc_util_create_ndef_record_with_carrier_config((ndef_record_s**) record, (net_nfc_carrier_config_s *) config);
+ return net_nfc_util_create_ndef_record_with_carrier_config(record, config);
}
API net_nfc_error_e net_nfc_create_carrier_config_from_config_record(
- net_nfc_carrier_config_h * config, ndef_record_h record)
+ net_nfc_carrier_config_s **config, ndef_record_s *record)
{
- return net_nfc_util_create_carrier_config_from_config_record ((net_nfc_carrier_config_s **) config, (ndef_record_s *) record);
+ return net_nfc_util_create_carrier_config_from_config_record(config, record);
}
API net_nfc_error_e net_nfc_append_carrier_config_record(
- ndef_message_h message,
- ndef_record_h record,
+ ndef_message_s *message,
+ ndef_record_s *record,
net_nfc_conn_handover_carrier_state_e power_status)
{
- return net_nfc_util_append_carrier_config_record((ndef_message_s *) message, (ndef_record_s *) record, power_status);
+ return net_nfc_util_append_carrier_config_record(message, record, power_status);
}
API net_nfc_error_e net_nfc_remove_carrier_config_record(
- ndef_message_h message, ndef_record_h record)
+ ndef_message_s *message, ndef_record_s *record)
{
- return net_nfc_util_remove_carrier_config_record ((ndef_message_s *) message, (ndef_record_s *) record);
+ return net_nfc_util_remove_carrier_config_record(message, record);
}
-API net_nfc_error_e net_nfc_get_carrier_config_record(ndef_message_h message,
- int index, ndef_record_h * record)
+API net_nfc_error_e net_nfc_get_carrier_config_record(ndef_message_s *message,
+ int index, ndef_record_s **record)
{
- return net_nfc_util_get_carrier_config_record((ndef_message_s *) message, index, (ndef_record_s **) record);
+ return net_nfc_util_get_carrier_config_record(message, index, record);
}
API net_nfc_error_e net_nfc_get_handover_random_number(
- ndef_message_h message, unsigned short* random_number)
+ ndef_message_s *message, unsigned short* random_number)
{
- return net_nfc_util_get_handover_random_number((ndef_message_s *) message, random_number);
+ return net_nfc_util_get_handover_random_number(message, random_number);
}
API net_nfc_error_e net_nfc_get_alternative_carrier_record_count(
- ndef_message_h message, unsigned int * count)
+ ndef_message_s *message, unsigned int *count)
{
- return net_nfc_util_get_alternative_carrier_record_count((ndef_message_s *) message, count);
+ return net_nfc_util_get_alternative_carrier_record_count(message, count);
}
API net_nfc_error_e net_nfc_get_alternative_carrier_power_status(
- ndef_message_h message, int index, net_nfc_conn_handover_carrier_state_e * power_state)
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e *power_state)
{
- return net_nfc_util_get_alternative_carrier_power_status((ndef_message_s *) message, index, power_state);
+ return net_nfc_util_get_alternative_carrier_power_status(message, index, power_state);
}
API net_nfc_error_e net_nfc_set_alternative_carrier_power_status(
- ndef_message_h message, int index, net_nfc_conn_handover_carrier_state_e power_status)
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e power_status)
{
- return net_nfc_util_set_alternative_carrier_power_status((ndef_message_s *) message, index, power_status);
+ return net_nfc_util_set_alternative_carrier_power_status(message, index,
+ power_status);
}
-API net_nfc_error_e net_nfc_get_alternative_carrier_type(ndef_message_h message,
+API net_nfc_error_e net_nfc_get_alternative_carrier_type(ndef_message_s *message,
int index, net_nfc_conn_handover_carrier_type_e * type)
{
- return net_nfc_util_get_alternative_carrier_type((ndef_message_s *) message, index, type);
+ return net_nfc_util_get_alternative_carrier_type(message, index, type);
}
API net_nfc_error_e net_nfc_create_handover_request_message(
- ndef_message_h * message)
+ ndef_message_s **message)
{
- return net_nfc_util_create_handover_request_message((ndef_message_s **) message);
+ return net_nfc_util_create_handover_request_message(message);
}
API net_nfc_error_e net_nfc_create_handover_select_message(
- ndef_message_h * message)
+ ndef_message_s **message)
{
- return net_nfc_util_create_handover_select_message((ndef_message_s **) message);
+ return net_nfc_util_create_handover_select_message(message);
}
API net_nfc_error_e net_nfc_create_handover_error_record(
- ndef_record_h * record, uint8_t reason, uint32_t data)
+ ndef_record_s **record, uint8_t reason, uint32_t data)
{
- return net_nfc_util_create_handover_error_record ((ndef_record_s**) record, reason, data);
-}
\ No newline at end of file
+ return net_nfc_util_create_handover_error_record(record, reason, data);
+}
#include "net_nfc_util_internal.h"
#include "net_nfc_util_ndef_record.h"
-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)
+API net_nfc_error_e net_nfc_create_record(ndef_record_s **record,
+ net_nfc_record_tnf_e tnf,
+ const data_s *typeName,
+ const data_s *id,
+ const data_s *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, typeName, id, payload, record);
}
-API net_nfc_error_e net_nfc_create_text_type_record(ndef_record_h* record, const char* text, const char* language_code_str, net_nfc_encode_type_e encode)
+API net_nfc_error_e net_nfc_create_text_type_record(ndef_record_s **record,
+ const char* text, const char* language_code_str, net_nfc_encode_type_e encode)
{
- return net_nfc_util_create_text_type_record(text, language_code_str, encode, (ndef_record_s**)record);
+ return net_nfc_util_create_text_type_record(text, language_code_str, encode, record);
}
-API net_nfc_error_e net_nfc_create_uri_type_record(ndef_record_h* record, const char* uri, net_nfc_schema_type_e protocol_schema)
+API net_nfc_error_e net_nfc_create_uri_type_record(ndef_record_s **record,
+ const char* uri, net_nfc_schema_type_e protocol_schema)
{
- return net_nfc_util_create_uri_type_record(uri, protocol_schema, (ndef_record_s**)record);
+ return net_nfc_util_create_uri_type_record(uri, protocol_schema, record);
}
-API net_nfc_error_e net_nfc_free_record(ndef_record_h record)
+API net_nfc_error_e net_nfc_free_record(ndef_record_s *record)
{
- return net_nfc_util_free_record((ndef_record_s*)record);
+ return net_nfc_util_free_record(record);
}
-API net_nfc_error_e net_nfc_get_record_payload(ndef_record_h record, data_h * payload)
+API net_nfc_error_e net_nfc_get_record_payload(ndef_record_s *record,
+ data_s **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 = &(record->payload_s);
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_get_record_type(ndef_record_h record, data_h * type)
+API net_nfc_error_e net_nfc_get_record_type(ndef_record_s *record, data_s **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 = &(record->type_s);
return NET_NFC_OK;
-
}
-API net_nfc_error_e net_nfc_get_record_id(ndef_record_h record, data_h * id)
+API net_nfc_error_e net_nfc_get_record_id(ndef_record_s *record, data_s **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 = &(record->id_s);
return NET_NFC_OK;
-
}
-API net_nfc_error_e net_nfc_get_record_tnf(ndef_record_h record, net_nfc_record_tnf_e * TNF)
+API net_nfc_error_e net_nfc_get_record_tnf(ndef_record_s *record,
+ net_nfc_record_tnf_e *TNF)
{
- ndef_record_s *struct_record = (ndef_record_s *)record;
-
if (record == NULL || TNF == NULL)
{
return NET_NFC_NULL_PARAMETER;
}
- *TNF = (net_nfc_record_tnf_e)struct_record->TNF;
+ *TNF = (net_nfc_record_tnf_e)record->TNF;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_set_record_id(ndef_record_h record, data_h id)
+API net_nfc_error_e net_nfc_set_record_id(ndef_record_s *record, data_s *id)
{
-
- data_s * tmp_id = (data_s *)id;
-
- if (record == NULL || tmp_id == NULL)
+ if (record == NULL || id == NULL)
{
return NET_NFC_NULL_PARAMETER;
}
- return net_nfc_util_set_record_id((ndef_record_s *)record,
- tmp_id->buffer, tmp_id->length);
+ return net_nfc_util_set_record_id(record, id->buffer, id->length);
}
-API net_nfc_error_e net_nfc_get_record_flags(ndef_record_h record, uint8_t * flag)
+API net_nfc_error_e net_nfc_get_record_flags(ndef_record_s *record, uint8_t *flag)
{
- ndef_record_s *struct_record = (ndef_record_s *)record;
-
if (record == NULL || flag == NULL)
{
return NET_NFC_NULL_PARAMETER;
}
- *flag = struct_record->MB;
+ *flag = record->MB;
*flag <<= 1;
- *flag += struct_record->ME;
+ *flag += record->ME;
*flag <<= 1;
- *flag += struct_record->CF;
+ *flag += record->CF;
*flag <<= 1;
- *flag += struct_record->SR;
+ *flag += record->SR;
*flag <<= 1;
- *flag += struct_record->IL;
+ *flag += record->IL;
*flag <<= 3;
- *flag += struct_record->TNF;
+ *flag += record->TNF;
return NET_NFC_OK;
}
return ((flag >> 3) & 0x01);
}
-static bool _is_text_record(ndef_record_h record)
+static bool _is_text_record(ndef_record_s *record)
{
bool result = false;
- data_h type;
+ data_s *type;
- if ((net_nfc_get_record_type(record, &type) == NET_NFC_OK) &&
- (strncmp((char *)net_nfc_get_data_buffer(type),
- TEXT_RECORD_TYPE,
- net_nfc_get_data_length(type)) == 0))
+ if ((net_nfc_get_record_type(record, &type) == NET_NFC_OK)
+ && (strncmp((char *)net_nfc_get_data_buffer(type),
+ TEXT_RECORD_TYPE,
+ net_nfc_get_data_length(type)) == 0))
+ {
result = true;
+ }
return result;
}
API net_nfc_error_e net_nfc_create_text_string_from_text_record(
- ndef_record_h record, char** buffer)
+ ndef_record_s *record, char **buffer)
{
net_nfc_error_e result;
- data_h payload;
+ data_s *payload;
if (record == NULL || buffer == NULL)
return NET_NFC_NULL_PARAMETER;
}
API net_nfc_error_e net_nfc_get_languange_code_string_from_text_record(
- ndef_record_h record, char** lang_code_str)
+ ndef_record_s *record, char **lang_code_str)
{
net_nfc_error_e result;
- data_h payload;
+ data_s *payload;
if (record == NULL || lang_code_str == NULL)
return NET_NFC_NULL_PARAMETER;
}
API net_nfc_error_e net_nfc_get_encoding_type_from_text_record(
- ndef_record_h record, net_nfc_encode_type_e * encoding)
+ ndef_record_s *record, net_nfc_encode_type_e *encoding)
{
net_nfc_error_e result;
- data_h payload;
+ data_s *payload;
if (record == NULL || encoding == NULL)
return NET_NFC_NULL_PARAMETER;
}
API net_nfc_error_e net_nfc_create_uri_string_from_uri_record(
- ndef_record_h record, char **uri)
+ ndef_record_s *record, char **uri)
{
- return net_nfc_util_create_uri_string_from_uri_record((ndef_record_s *)record, uri);
+ return net_nfc_util_create_uri_string_from_uri_record(record, uri);
}
}
-API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_h handle,
- data_h data, net_nfc_client_p2p_send_completed callback, void *user_data)
+API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_s *handle,
+ data_s *data, net_nfc_client_p2p_send_completed callback, void *user_data)
{
GVariant *arg_data;
NetNfcCallback *func_data;
-API net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_h handle,
- data_h data)
+API net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_s *handle,
+ data_s *data)
{
GVariant *arg_data;
GError *error = NULL;
net_nfc_util_gdbus_variant_to_data_s(arg_data, &buffer_data);
- callback((net_nfc_target_handle_h)arg_handle, arg_se_type, &buffer_data,
+ callback((net_nfc_target_handle_s*)arg_handle, arg_se_type, &buffer_data,
se_esedetecthandler.se_ese_detected_data);
net_nfc_util_free_data(&buffer_data);
net_nfc_se_open_se_cb se_callback =
(net_nfc_se_open_se_cb)func_data->se_callback;
- se_callback(result, (net_nfc_target_handle_h)out_handle, func_data->se_data);
+ se_callback(result, (net_nfc_target_handle_s*)out_handle, func_data->se_data);
}
g_free(func_data);
API net_nfc_error_e net_nfc_client_se_open_internal_secure_element_sync(
- net_nfc_se_type_e se_type, net_nfc_target_handle_h *handle)
+ net_nfc_se_type_e se_type, net_nfc_target_handle_s **handle)
{
net_nfc_error_e result = NET_NFC_OK;
guint out_handle = 0;
API net_nfc_error_e net_nfc_client_se_close_internal_secure_element(
- net_nfc_target_handle_h handle, net_nfc_se_close_se_cb callback, void *user_data)
+ net_nfc_target_handle_s *handle, net_nfc_se_close_se_cb callback, void *user_data)
{
SeFuncData *func_data;
API net_nfc_error_e net_nfc_client_se_close_internal_secure_element_sync(
- net_nfc_target_handle_h handle)
+ net_nfc_target_handle_s *handle)
{
net_nfc_error_e result = NET_NFC_OK;
GError *error = NULL;
}
-API net_nfc_error_e net_nfc_client_se_get_atr(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_se_get_atr(net_nfc_target_handle_s *handle,
net_nfc_se_get_atr_cb callback, void *user_data)
{
SeFuncData *func_data;
API net_nfc_error_e net_nfc_client_se_get_atr_sync(
- net_nfc_target_handle_h handle, data_h *atr)
+ net_nfc_target_handle_s *handle, data_s **atr)
{
net_nfc_error_e result = NET_NFC_OK;
GVariant *out_atr = NULL;
}
-API net_nfc_error_e net_nfc_client_se_send_apdu(net_nfc_target_handle_h handle,
- data_h apdu_data, net_nfc_se_send_apdu_cb callback, void *user_data)
+API net_nfc_error_e net_nfc_client_se_send_apdu(net_nfc_target_handle_s *handle,
+ data_s *apdu_data, net_nfc_se_send_apdu_cb callback, void *user_data)
{
SeFuncData *func_data;
GVariant *arg_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(apdu_data);
if (arg_data == NULL)
return NET_NFC_INVALID_PARAM;
API net_nfc_error_e net_nfc_client_se_send_apdu_sync(
- net_nfc_target_handle_h handle, data_h apdu_data, data_h *response)
+ net_nfc_target_handle_s *handle, data_s *apdu_data, data_s **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(apdu_data);
if (arg_data == NULL)
return NET_NFC_INVALID_PARAM;
#include "net_nfc_debug_internal.h"
#include "net_nfc_util_sign_record.h"
-API net_nfc_error_e net_nfc_sign_records(ndef_message_h msg, int begin_index,
+API net_nfc_error_e net_nfc_sign_records(ndef_message_s *msg, int begin_index,
int end_index, char *cert_file, char *password)
{
return net_nfc_util_sign_records((ndef_message_s *)msg, begin_index, end_index, cert_file, password);
}
-API net_nfc_error_e net_nfc_sign_ndef_message(ndef_message_h msg,
+API net_nfc_error_e net_nfc_sign_ndef_message(ndef_message_s *msg,
char *cert_file, char *password)
{
return net_nfc_util_sign_ndef_message((ndef_message_s *)msg, cert_file, password);
}
-API net_nfc_error_e net_nfc_verify_signature_ndef_message(ndef_message_h msg)
+API net_nfc_error_e net_nfc_verify_signature_ndef_message(ndef_message_s *msg)
{
return net_nfc_util_verify_signature_ndef_message((ndef_message_s *)msg);
}
-API net_nfc_error_e net_nfc_verify_signature_records(ndef_record_h begin_record,
- ndef_record_h sign_record)
+API net_nfc_error_e net_nfc_verify_signature_records(ndef_record_s *begin_record,
+ ndef_record_s *sign_record)
{
- return net_nfc_util_verify_signature_records((ndef_record_s *)begin_record, (ndef_record_s *)sign_record);
+ return net_nfc_util_verify_signature_records(begin_record, sign_record);
}
(guint *)&handle);
if (callback != NULL) {
- ndef_message_h message;
+ ndef_message_s *message = NULL;
message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
}
API net_nfc_error_e net_nfc_client_snep_start_server(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
const char *san,
sap_t sap,
net_nfc_client_snep_event_cb callback,
}
API net_nfc_error_e net_nfc_client_snep_start_client(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
const char *san,
sap_t sap,
net_nfc_client_snep_event_cb callback,
API net_nfc_error_e net_nfc_client_snep_send_client_request(
net_nfc_snep_handle_h target,
net_nfc_snep_type_t snep_type,
- ndef_message_h msg,
+ ndef_message_s *msg,
net_nfc_client_snep_event_cb callback,
void *user_data)
{
}
#if 0
API net_nfc_error_e net_nfc_client_snep_send_client_request_sync(
- net_nfc_target_handle_h target,
+ net_nfc_target_handle_s *target,
net_nfc_snep_type_t snep_type,
- ndef_message_h msg,
+ ndef_message_s *msg,
net_nfc_snep_type_t *resp_type,
- ndef_message_h *response)
+ ndef_message_s **response)
{
GVariant *resp_msg = NULL;
GVariant *arg_msg = NULL;
}
#endif
API net_nfc_error_e net_nfc_client_snep_stop_service_sync(
- net_nfc_target_handle_h target, net_nfc_snep_handle_h service)
+ net_nfc_target_handle_s *target, net_nfc_snep_handle_h service)
{
GError *error = NULL;
net_nfc_error_e result = NET_NFC_OK;
if (callback != NULL)
{
- ndef_message_h message;
-
+ ndef_message_s *message;
message = net_nfc_util_gdbus_variant_to_ndef_message(arg_ndef_msg);
callback(GUINT_TO_POINTER(arg_handle), arg_event, arg_result,
while (i < number_of_keys)
{
gchar *str = NULL;
- data_h value = NULL;
+ data_s *value = NULL;
/* key */
length = *pos; /* first values is length of key */
}
if (out_result == NET_NFC_OK && out_is_connected == true) {
- net_nfc_release_tag_info((net_nfc_target_info_h)client_target_info);
+ net_nfc_release_tag_info(client_target_info);
client_target_info = NULL;
if (tag_check_filter(out_dev_type) == true) {
{
NetNfcCallback *func_data = (NetNfcCallback *)user_data;
net_nfc_error_e out_result = NET_NFC_OK;
- net_nfc_target_handle_h out_handle = NULL;
+ net_nfc_target_handle_s *out_handle = NULL;
net_nfc_target_type_e out_dev_type = NET_NFC_UNKNOWN_TARGET;
gboolean out_is_connected = false;
GError *error = NULL;
{
NFC_INFO(">>> SIGNAL arrived");
- net_nfc_release_tag_info((net_nfc_target_info_h)client_target_info);
+ net_nfc_release_tag_info(client_target_info);
client_target_info = NULL;
if (tag_check_filter(arg_dev_type) == FALSE) {
NFC_INFO("The detected target is filtered out, type [%d]", arg_dev_type);
}
- net_nfc_release_tag_info((net_nfc_target_info_h)client_target_info);
+ net_nfc_release_tag_info(client_target_info);
client_target_info = NULL;
}
#endif
API net_nfc_error_e net_nfc_client_tag_get_current_tag_info_sync(
- net_nfc_target_info_h *info)
+ net_nfc_target_info_s **info)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_target_type_e out_dev_type = NET_NFC_UNKNOWN_TARGET;
#endif
API net_nfc_error_e net_nfc_client_tag_get_current_target_handle_sync(
- net_nfc_target_handle_h *handle)
+ net_nfc_target_handle_s **handle)
{
net_nfc_target_info_s *info;
net_nfc_error_e result;
if (client_target_info)
{
- net_nfc_release_tag_info(
- (net_nfc_target_info_h)client_target_info);
+ net_nfc_release_tag_info(client_target_info);
client_target_info = NULL;
}
{
client_filter = NET_NFC_ALL_ENABLE;
- net_nfc_release_tag_info((net_nfc_target_info_h)client_target_info);
+ net_nfc_release_tag_info(client_target_info);
client_target_info = NULL;
net_nfc_client_tag_unset_tag_discovered();
#define FELICA_CMD_REQ_SYSTEM_CODE 0x0C
#define FELICA_TAG_KEY "IDm"
-API net_nfc_error_e net_nfc_client_felica_poll(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_felica_poll(net_nfc_target_handle_s *handle,
net_nfc_felica_poll_request_code_e req_code,
uint8_t time_slote,
nfc_transceive_data_callback callback,
rawdata.length = 6;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_felica_request_service(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_area_service,
uint16_t area_service_list[],
uint8_t number_of_services,
data_s rawdata;
- data_h IDm = NULL;
+ data_s *IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- FELICA_TAG_KEY,
- &IDm) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, FELICA_TAG_KEY, &IDm) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)IDm)->length != 8)
+ if (IDm->length != 8)
return NET_NFC_OUT_OF_BOUND;
if (number_of_area_service > 32)
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, IDm->buffer, IDm->length);
+ send_buffer = send_buffer + 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,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_felica_request_response(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback,
void *user_data)
{
data_s rawdata;
- data_h IDm = NULL;
+ data_s *IDm = NULL;
uint8_t send_buffer[10] = { 0x00, };
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- FELICA_TAG_KEY,
- &IDm) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, FELICA_TAG_KEY, &IDm) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)IDm)->length != 8)
+ if (IDm->length != 8)
return NET_NFC_OUT_OF_BOUND;
send_buffer[0] = 0xA;
send_buffer[1] = FELICA_CMD_REQ_RESPONSE;
- memcpy(send_buffer + 2, ((data_s*)IDm)->buffer, ((data_s*)IDm)->length);
+ memcpy(send_buffer + 2, IDm->buffer, IDm->length);
DEBUG_MSG_PRINT_BUFFER(send_buffer, 10);
rawdata.length = 10;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_felica_read_without_encryption(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_services,
uint16_t service_list[],
uint8_t number_of_blocks,
data_s rawdata;
- data_h IDm = NULL;
+ data_s *IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- FELICA_TAG_KEY,
- &IDm) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, FELICA_TAG_KEY, &IDm) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)IDm)->length != 8)
+ if (IDm->length != 8)
return NET_NFC_OUT_OF_BOUND;
if (number_of_services > 16)
*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, IDm->buffer, IDm->length);
+ send_buffer = send_buffer + 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,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_felica_write_without_encryption(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t number_of_services,
uint16_t service_list[],
uint8_t number_of_blocks,
uint8_t block_list[],
- data_h data,
+ data_s *data,
nfc_transceive_data_callback callback,
void *user_data)
{
data_s rawdata;
- data_h IDm = NULL;
+ data_s *IDm = NULL;
uint32_t send_buffer_length;
uint8_t* send_buffer = NULL;
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- FELICA_TAG_KEY,
- &IDm) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, FELICA_TAG_KEY, &IDm) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)IDm)->length != 8)
+ if (IDm->length != 8)
return NET_NFC_OUT_OF_BOUND;
if (number_of_services > 16)
return NET_NFC_OUT_OF_BOUND;
- if (((data_s*)data)->length > 16 * number_of_blocks)
+ if (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;
+ + 1 + number_of_blocks + data->length;
- _net_nfc_util_alloc_mem(send_buffer,
- send_buffer_length * sizeof(uint8_t));
+ _net_nfc_util_alloc_mem(send_buffer, send_buffer_length * sizeof(uint8_t));
if (send_buffer == NULL)
return NET_NFC_ALLOC_FAIL;
*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, IDm->buffer, IDm->length);
+ send_buffer = send_buffer + 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, data->buffer, 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,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_felica_request_system_code(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback,
void *user_data)
{
data_s rawdata;
- data_h IDm = NULL;
+ data_s *IDm = NULL;
uint8_t send_buffer[10] = { 0x00, };
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- FELICA_TAG_KEY,
- &IDm) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, FELICA_TAG_KEY, &IDm) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if (((data_s*)IDm)->length != 8)
+ if (IDm->length != 8)
return NET_NFC_OUT_OF_BOUND;
send_buffer[0] = 0xA;
send_buffer[1] = FELICA_CMD_REQ_SYSTEM_CODE;
- memcpy(send_buffer + 2,
- ((data_s *)IDm)->buffer,
- ((data_s *)IDm)->length);
+ memcpy(send_buffer + 2, IDm->buffer, IDm->length);
DEBUG_MSG_PRINT_BUFFER(send_buffer, 10);
rawdata.length = 10;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ &rawdata,
callback,
user_data);
}
#include <glib.h>
-#include "net_nfc_typedef_internal.h"
+#include "net_nfc_typedef.h"
gboolean net_nfc_client_tag_is_connected(void);
#define JEWEL_CMD_WRITE_NE 0x1A
#define JEWEL_TAG_KEY "UID"
-API net_nfc_error_e net_nfc_client_jewel_read_id(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_jewel_read_id(net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
rawdata.buffer = send_buffer;
rawdata.length = 9;
- return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
- callback,
- user_data);
+ return net_nfc_client_transceive_data(handle, &rawdata, callback, user_data);
}
-API net_nfc_error_e net_nfc_client_jewel_read_byte(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_jewel_read_byte(net_nfc_target_handle_s *handle,
uint8_t block, uint8_t byte, nfc_transceive_data_callback callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t send_buffer[9] = {0x00, };
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if(net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- JEWEL_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if(net_nfc_get_tag_info_value(target_info, JEWEL_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
-
- if(((data_s*)UID)->length != 4)
+ if(UID->length != 4)
return NET_NFC_OUT_OF_BOUND;
/* command */
send_buffer[2] = 0x00;
/* UID0 ~ 3 */
- memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ memcpy(&(send_buffer[3]), UID->buffer, UID->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.buffer = send_buffer;
rawdata.length = 9;
- return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
- callback,
- user_data);
+ return net_nfc_client_transceive_data(handle, &rawdata, callback, user_data);
}
-API net_nfc_error_e net_nfc_client_jewel_read_all(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_jewel_read_all(net_nfc_target_handle_s *handle,
nfc_transceive_data_callback callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t send_buffer[9] = {0x00, };
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if(net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- JEWEL_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if(net_nfc_get_tag_info_value(target_info, JEWEL_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if(((data_s*)UID)->length != 4)
+ if(UID->length != 4)
return NET_NFC_OUT_OF_BOUND;
/* command */
send_buffer[2] = 0x00;
/* UID0 ~ 3 */
- memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ memcpy(&(send_buffer[3]), UID->buffer, UID->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.buffer = send_buffer;
rawdata.length = 9;
- return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
- callback,
- user_data);
+ return net_nfc_client_transceive_data(handle, &rawdata, callback, user_data);
}
API net_nfc_error_e net_nfc_client_jewel_write_with_erase(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t block,
uint8_t byte,
uint8_t data,
{
net_nfc_target_info_s *target_info = NULL;
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t send_buffer[9] = {0x00, };
if(handle == NULL)
if (target_info == NULL)
return NET_NFC_NO_DATA_FOUND;
- if(net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- JEWEL_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if(net_nfc_get_tag_info_value(target_info, JEWEL_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if(((data_s*)UID)->length != 4)
+ if(UID->length != 4)
return NET_NFC_OUT_OF_BOUND;
/* command */
send_buffer[2] = data;
/* UID0 ~ 3 */
- memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ memcpy(&(send_buffer[3]), UID->buffer, UID->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.buffer = send_buffer;
rawdata.length = 9;
- return net_nfc_client_transceive(handle,
- (data_h)&rawdata,
- callback,
- user_data);
-
+ return net_nfc_client_transceive(handle, &rawdata, callback, user_data);
}
API net_nfc_error_e net_nfc_client_jewel_write_with_no_erase(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t block,
uint8_t byte,
uint8_t data,
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t send_buffer[9] = {0x00, };
return NET_NFC_NOT_ALLOWED_OPERATION;
}
- if(net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- JEWEL_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if(net_nfc_get_tag_info_value(target_info, JEWEL_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
- if(((data_s*)UID)->length != 4)
+ if(UID->length != 4)
return NET_NFC_OUT_OF_BOUND;
/* command */
send_buffer[2] = data;
/* UID0 ~ 3 */
- memcpy(&(send_buffer[3]),
- ((data_s*)UID)->buffer,
- ((data_s*)UID)->length);
+ memcpy(&(send_buffer[3]), UID->buffer, UID->length);
net_nfc_util_compute_CRC(CRC_B, send_buffer, 9);
rawdata.buffer = send_buffer;
rawdata.length = 9;
- return net_nfc_client_transceive(handle,
- (data_h)&rawdata,
- callback,
- user_data);
+ return net_nfc_client_transceive(handle, &rawdata, callback, user_data);
}
API net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyA(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t sector,
- data_h auth_key,
+ data_s *auth_key,
void *callback,
void *user_data)
{
net_nfc_target_info_s* target_info = NULL;
- data_s *key;
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t* send_buffer = NULL;
uint8_t* temp = NULL;
int send_buffer_length = 0;
uint8_t sector_to_block = 0;
-
+ net_nfc_error_e result;
if (handle == NULL || auth_key == NULL)
return NET_NFC_NULL_PARAMETER;
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_OPERATION_FAIL;
- key = (data_s *)auth_key;
-
- if (key->length != 6)
+ if (auth_key->length != 6)
return NET_NFC_OUT_OF_BOUND;
target_info = net_nfc_client_tag_get_client_target_info();
}
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- MIFARE_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, MIFARE_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
/* cmd + addr + UID + AUTH_KEY + CRC_A */
- send_buffer_length = 1 + 1 + ((data_s*)UID)->length
- + key->length + 2;
+ send_buffer_length = 1 + 1 + UID->length + auth_key->length + 2;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
*temp = sector_to_block;
temp++;
- memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
- temp = temp + ((data_s*)UID)->length;
+ memcpy(temp, UID->buffer, UID->length);
+ temp = temp + UID->length;
- memcpy(temp, key->buffer, key->length);
+ memcpy(temp, auth_key->buffer, auth_key->length);
net_nfc_util_compute_CRC(CRC_A, send_buffer, send_buffer_length);
rawdata.buffer = send_buffer;
rawdata.length = send_buffer_length;
- net_nfc_error_e result = net_nfc_client_transceive(handle,
- (data_h)&rawdata,
- callback,
- user_data);
+ result = net_nfc_client_transceive(handle, &rawdata, callback, user_data);
if (send_buffer != NULL)
_net_nfc_util_free_mem(send_buffer);
}
API net_nfc_error_e net_nfc_client_mifare_authenticate_with_keyB(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t sector,
- data_h auth_key,
+ data_s *auth_key,
void *callback,
void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
- data_s *key;
data_s rawdata;
- data_h UID = NULL;
+ data_s *UID = NULL;
uint8_t* send_buffer = NULL;
uint8_t* temp = NULL;
int send_buffer_length = 0;
if (net_nfc_client_tag_is_connected() == FALSE)
return NET_NFC_OPERATION_FAIL;
- key = (data_s *)auth_key;
-
- if (key->length != 6)
+ if (auth_key->length != 6)
return NET_NFC_OUT_OF_BOUND;
target_info = net_nfc_client_tag_get_client_target_info();
}
}
- if (net_nfc_get_tag_info_value((net_nfc_target_info_h)target_info,
- MIFARE_TAG_KEY,
- &UID) != NET_NFC_OK)
+ if (net_nfc_get_tag_info_value(target_info, MIFARE_TAG_KEY, &UID) != NET_NFC_OK)
{
return NET_NFC_NO_DATA_FOUND;
}
break;
}
- send_buffer_length = 1 + 1 + ((data_s*)UID)->length
- + key->length + 2; /* cmd + addr + UID + AUTH_KEY + CRC_A */
+ /* cmd + addr + UID + AUTH_KEY + CRC_A */
+ send_buffer_length = 1 + 1 + UID->length + auth_key->length + 2;
_net_nfc_util_alloc_mem(send_buffer, send_buffer_length
* sizeof(uint8_t));
*temp = sector_to_block;
temp++;
- memcpy(temp, ((data_s*)UID)->buffer, ((data_s*)UID)->length);
- temp = temp + ((data_s*)UID)->length;
+ memcpy(temp, UID->buffer, UID->length);
+ temp = temp + UID->length;
- memcpy(temp, key->buffer, key->length);
+ memcpy(temp, auth_key->buffer, auth_key->length);
net_nfc_util_compute_CRC(CRC_A, send_buffer, send_buffer_length);
rawdata.buffer = send_buffer;
rawdata.length = send_buffer_length;
- result = net_nfc_client_transceive(handle, (data_h)&rawdata, callback, user_data);
+ result = net_nfc_client_transceive(handle, &rawdata, callback, user_data);
if (send_buffer != NULL)
_net_nfc_util_free_mem(send_buffer);
return result;
}
-API net_nfc_error_e net_nfc_client_mifare_read(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_mifare_read(net_nfc_target_handle_s *handle,
uint8_t addr, void *callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
rawdata.length = 4;
return net_nfc_client_transceive_data(handle,
- (data_h)&rawdata,
+ &rawdata,
callback,
user_data);
}
API net_nfc_error_e net_nfc_client_mifare_write_block(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
- data_h data,
+ data_s *data,
void *callback,
void *user_data)
{
if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC)
{
- if (((data_s *)data)->length > MIFARE_PAGE_SIZE)
+ if (data->length > MIFARE_PAGE_SIZE)
{
uint8_t* temp = NULL;
*temp = addr;
temp++;
- memcpy(temp, ((data_s*)data)->buffer, MIFARE_PAGE_SIZE);
+ memcpy(temp, data->buffer, MIFARE_PAGE_SIZE);
}
else
uint8_t* temp = NULL;
/* cmd + addr + page + CRC */
- send_buffer_length = 1 + 1 +
- ((data_s*)data)->length + 2;
+ send_buffer_length = 1 + 1 + data->length + 2;
_net_nfc_util_alloc_mem(send_buffer,
send_buffer_length * sizeof(uint8_t));
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ memcpy(temp, data->buffer, data->length);
}
}
else
{
- if (((data_s*)data)->length > MIFARE_BLOCK_SIZE)
+ if (data->length > MIFARE_BLOCK_SIZE)
{
uint8_t* temp = NULL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- MIFARE_BLOCK_SIZE);
+ memcpy(temp, data->buffer, MIFARE_BLOCK_SIZE);
}
else
{
uint8_t* temp = NULL;
/* cmd + addr + page + CRC */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length
- + 2;
+ send_buffer_length = 1 + 1 + data->length + 2;
- _net_nfc_util_alloc_mem(send_buffer,
- send_buffer_length * sizeof(uint8_t));
+ _net_nfc_util_alloc_mem(send_buffer, send_buffer_length * sizeof(uint8_t));
if (send_buffer == NULL)
return NET_NFC_ALLOC_FAIL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ memcpy(temp, data->buffer, data->length);
}
}
rawdata.buffer = send_buffer;
rawdata.length = send_buffer_length;
- result = net_nfc_client_transceive(handle, (data_h)&rawdata, callback, user_data);
+ result = net_nfc_client_transceive(handle, &rawdata, callback, user_data);
if (send_buffer != NULL)
_net_nfc_util_free_mem(send_buffer);
}
API net_nfc_error_e net_nfc_client_mifare_write_page(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
- data_h data,
+ data_s *data,
void *callback,
void *user_data)
{
if (target_info->devType == NET_NFC_MIFARE_ULTRA_PICC)
{
- if (((data_s*)data)->length > MIFARE_PAGE_SIZE)
+ if (data->length > MIFARE_PAGE_SIZE)
{
uint8_t* temp = NULL;
/* cmd + addr + page + CRC */
send_buffer_length = 1 + 1 + MIFARE_PAGE_SIZE + 2;
- _net_nfc_util_alloc_mem(send_buffer,
- send_buffer_length * sizeof(uint8_t));
+ _net_nfc_util_alloc_mem(send_buffer, send_buffer_length * sizeof(uint8_t));
if (send_buffer == NULL)
return NET_NFC_ALLOC_FAIL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- MIFARE_PAGE_SIZE);
+ memcpy(temp, data->buffer, MIFARE_PAGE_SIZE);
}
else
{
uint8_t* temp = NULL;
/* cmd + addr + page + CRC */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length
- + 2;
+ send_buffer_length = 1 + 1 + data->length + 2;
- _net_nfc_util_alloc_mem(send_buffer,
- send_buffer_length * sizeof(uint8_t));
+ _net_nfc_util_alloc_mem(send_buffer, send_buffer_length * sizeof(uint8_t));
if (send_buffer == NULL)
return NET_NFC_ALLOC_FAIL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ memcpy(temp, data->buffer, data->length);
}
}
else
{
- if (((data_s*)data)->length > MIFARE_PAGE_SIZE)
+ if (data->length > MIFARE_PAGE_SIZE)
{
uint8_t* temp = NULL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- MIFARE_PAGE_SIZE);
+ memcpy(temp, data->buffer, MIFARE_PAGE_SIZE);
}
else
uint8_t* temp = NULL;
/* cmd + addr + page + CRC */
- send_buffer_length = 1 + 1 + ((data_s*)data)->length
- + 2;
+ send_buffer_length = 1 + 1 + data->length + 2;
- _net_nfc_util_alloc_mem(send_buffer,
- send_buffer_length * sizeof(uint8_t));
+ _net_nfc_util_alloc_mem(send_buffer, send_buffer_length * sizeof(uint8_t));
if (send_buffer == NULL)
return NET_NFC_ALLOC_FAIL;
*temp = addr;
temp++;
- memcpy(temp,
- ((data_s*)data)->buffer,
- ((data_s*)data)->length);
+ memcpy(temp, data->buffer, data->length);
}
}
rawdata.buffer = send_buffer;
rawdata.length = send_buffer_length;
- result = net_nfc_client_transceive(handle, (data_h)&rawdata, callback, user_data);
+ result = net_nfc_client_transceive(handle, &rawdata, callback, user_data);
if (send_buffer != NULL)
_net_nfc_util_free_mem(send_buffer);
}
API net_nfc_error_e net_nfc_client_mifare_increment(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
int value,
void *callback,
send_buffer[1] = addr;
/* little endian.
- little value of byte array will be saved first in memory */
+ little value of byte array will be saved first in memory */
send_buffer[5] = (value & 0xFF000000) >> 24;
send_buffer[4] = (value & 0x00FF0000) >> 16;
send_buffer[3] = (value & 0x0000FF00) >> 8;
rawdata.buffer = send_buffer;
rawdata.length = 8;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, &rawdata, callback,
user_data);
}
API net_nfc_error_e net_nfc_client_mifare_decrement(
- net_nfc_target_handle_h handle,
+ net_nfc_target_handle_s *handle,
uint8_t addr,
int value,
void *callback,
send_buffer[1] = addr;
/* little endian.
- little value of byte array will be saved first in memory */
+ little value of byte array will be saved first in memory */
send_buffer[5] = (value & 0xFF000000) >> 24;
send_buffer[4] = (value & 0x00FF0000) >> 16;
send_buffer[3] = (value & 0x0000FF00) >> 8;
rawdata.buffer = send_buffer;
rawdata.length = 8;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, &rawdata, callback,
user_data);
}
-API net_nfc_error_e net_nfc_client_mifare_transfer(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_mifare_transfer(net_nfc_target_handle_s *handle,
uint8_t addr, void *callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
rawdata.buffer = send_buffer;
rawdata.length = 4;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, &rawdata, callback,
user_data);
}
-API net_nfc_error_e net_nfc_client_mifare_restore(net_nfc_target_handle_h handle,
+API net_nfc_error_e net_nfc_client_mifare_restore(net_nfc_target_handle_s *handle,
uint8_t addr, void *callback, void *user_data)
{
net_nfc_target_info_s *target_info = NULL;
rawdata.buffer = send_buffer;
rawdata.length = 4;
- return net_nfc_client_transceive(handle, (data_h)&rawdata, callback,
+ return net_nfc_client_transceive(handle, &rawdata, callback,
user_data);
}
-API net_nfc_error_e net_nfc_client_mifare_create_default_key(data_h* key)
+API net_nfc_error_e net_nfc_client_mifare_create_default_key(data_s** key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
}
API net_nfc_error_e net_nfc_client_mifare_create_application_directory_key(
- data_h* key)
+ data_s** key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
return net_nfc_create_data(key, mad_key, 6);
}
-API net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(data_h* key)
+API net_nfc_error_e net_nfc_client_mifare_create_net_nfc_forum_key(data_s** key)
{
if (key == NULL)
return NET_NFC_NULL_PARAMETER;
#include "net_nfc_target_info.h"
#include "net_nfc_util_internal.h"
-API net_nfc_error_e net_nfc_get_tag_type(net_nfc_target_info_h target_info,
+API net_nfc_error_e net_nfc_get_tag_type(net_nfc_target_info_s *target_info,
net_nfc_target_type_e *type)
{
- net_nfc_target_info_s *target_info_private =
- (net_nfc_target_info_s *)target_info;
-
if (type == NULL)
return NET_NFC_NULL_PARAMETER;
if (target_info == NULL)
return NET_NFC_INVALID_HANDLE;
- *type = target_info_private->devType;
-
+ *type = target_info->devType;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_get_tag_handle(net_nfc_target_info_h target_info,
- net_nfc_target_handle_h *handle)
+API net_nfc_error_e net_nfc_get_tag_handle(net_nfc_target_info_s *target_info,
+ net_nfc_target_handle_s **handle)
{
- net_nfc_target_info_s *target_info_private =
- (net_nfc_target_info_s *)target_info;
-
if (handle == NULL)
return NET_NFC_NULL_PARAMETER;
if (target_info == NULL)
return NET_NFC_INVALID_HANDLE;
- *handle = (net_nfc_target_handle_h)target_info_private->handle;
-
+ *handle = target_info->handle;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_get_tag_ndef_support(
- net_nfc_target_info_h target_info, bool *is_support)
+ net_nfc_target_info_s *target_info, bool *is_support)
{
- net_nfc_target_info_s *target_info_private =
- (net_nfc_target_info_s *)target_info;
-
if (target_info == NULL || is_support == NULL)
return NET_NFC_NULL_PARAMETER;
- *is_support = (bool)target_info_private->is_ndef_supported;
-
+ *is_support = (bool)target_info->is_ndef_supported;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_get_tag_max_data_size(
- net_nfc_target_info_h target_info, uint32_t * max_size)
+ net_nfc_target_info_s *target_info, uint32_t * max_size)
{
- net_nfc_target_info_s *target_info_private =
- (net_nfc_target_info_s *)target_info;
-
if (target_info == NULL || max_size == NULL)
return NET_NFC_NULL_PARAMETER;
- *max_size = target_info_private->maxDataSize;
-
+ *max_size = target_info->maxDataSize;
return NET_NFC_OK;
}
API net_nfc_error_e net_nfc_get_tag_actual_data_size(
- net_nfc_target_info_h target_info, uint32_t * actual_data)
+ net_nfc_target_info_s *target_info, uint32_t *actual_data)
{
- net_nfc_target_info_s *target_info_private =
- (net_nfc_target_info_s *)target_info;
-
if (target_info == NULL || actual_data == NULL)
return NET_NFC_NULL_PARAMETER;
- *actual_data = target_info_private->actualDataSize;
-
+ *actual_data = target_info->actualDataSize;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_get_tag_info_keys(net_nfc_target_info_h target_info,
+API net_nfc_error_e net_nfc_get_tag_info_keys(net_nfc_target_info_s *target_info,
char ***keys, int *number_of_keys)
{
- net_nfc_target_info_s *handle = (net_nfc_target_info_s *)target_info;
int i = 0;
if (keys == NULL || number_of_keys == NULL || target_info == NULL)
return NET_NFC_NULL_PARAMETER;
- if (handle->tag_info_list == NULL)
+ if (target_info->tag_info_list == NULL)
return NET_NFC_NO_DATA_FOUND;
- if (handle->number_of_keys <= 0)
+ if (target_info->number_of_keys <= 0)
return NET_NFC_NO_DATA_FOUND;
- if (handle->keylist != NULL)
+ if (target_info->keylist != NULL)
{
- *keys = handle->keylist;
+ *keys = target_info->keylist;
return NET_NFC_OK;
}
- _net_nfc_util_alloc_mem(*keys, handle->number_of_keys * sizeof(char *));
+ _net_nfc_util_alloc_mem(*keys, target_info->number_of_keys * sizeof(char *));
if (*keys == NULL)
return NET_NFC_ALLOC_FAIL;
- net_nfc_tag_info_s *tag_info = handle->tag_info_list;
+ net_nfc_tag_info_s *tag_info = target_info->tag_info_list;
- for (; i < handle->number_of_keys; i++, tag_info++)
+ for (; i < target_info->number_of_keys; i++, tag_info++)
{
(*keys)[i] = tag_info->key;
}
- *number_of_keys = handle->number_of_keys;
+ *number_of_keys = target_info->number_of_keys;
- NFC_DBG("number of keys = [%d]", handle->number_of_keys);
+ NFC_DBG("number of keys = [%d]", target_info->number_of_keys);
- handle->keylist = *keys;
+ target_info->keylist = *keys;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_get_tag_info_value(net_nfc_target_info_h target_info,
- const char *key, data_h *value)
+API net_nfc_error_e net_nfc_get_tag_info_value(net_nfc_target_info_s *target_info,
+ const char *key, data_s **value)
{
- net_nfc_target_info_s *handle = (net_nfc_target_info_s *)target_info;
+ int i;
net_nfc_tag_info_s *tag_info;
if (target_info == NULL || key == NULL || value == NULL)
return NET_NFC_NULL_PARAMETER;
- if (handle->tag_info_list == NULL)
+ if (target_info->tag_info_list == NULL)
return NET_NFC_NO_DATA_FOUND;
- int i = 0;
+ tag_info = target_info->tag_info_list;
- tag_info = handle->tag_info_list;
-
- for (; i < handle->number_of_keys; i++, tag_info++)
+ for (i=0;i < target_info->number_of_keys;i++, tag_info++)
{
if (strcmp(key, tag_info->key) == 0)
{
}
}
- if (i == handle->number_of_keys)
+ if (i == target_info->number_of_keys)
return NET_NFC_NO_DATA_FOUND;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_duplicate_target_info(net_nfc_target_info_h origin,
- net_nfc_target_info_h *result)
+API net_nfc_error_e net_nfc_duplicate_target_info(net_nfc_target_info_s *origin,
+ net_nfc_target_info_s **result)
{
- net_nfc_target_info_s *handle = (net_nfc_target_info_s *)origin;
net_nfc_target_info_s *temp = NULL;
- if (handle == NULL || result == NULL)
+ if (origin == NULL || result == NULL)
return NET_NFC_NULL_PARAMETER;
_net_nfc_util_alloc_mem(temp, sizeof(net_nfc_target_info_s));
if (temp == NULL)
return NET_NFC_ALLOC_FAIL;
- temp->ndefCardState = handle->ndefCardState;
- temp->actualDataSize = handle->actualDataSize;
- temp->maxDataSize = handle->maxDataSize;
- temp->devType = handle->devType;
- temp->handle = handle->handle;
- temp->is_ndef_supported = handle->is_ndef_supported;
- temp->number_of_keys = handle->number_of_keys;
+ temp->ndefCardState = origin->ndefCardState;
+ temp->actualDataSize = origin->actualDataSize;
+ temp->maxDataSize = origin->maxDataSize;
+ temp->devType = origin->devType;
+ temp->handle = origin->handle;
+ temp->is_ndef_supported = origin->is_ndef_supported;
+ temp->number_of_keys = origin->number_of_keys;
if (temp->number_of_keys > 0)
{
return NET_NFC_ALLOC_FAIL;
}
- for (i = 0; i < handle->number_of_keys; i++)
+ for (i = 0; i < origin->number_of_keys; i++)
{
- if (handle->tag_info_list[i].key != NULL)
- _net_nfc_util_strdup(temp->tag_info_list[i].key, handle->tag_info_list[i].key);
+ if (origin->tag_info_list[i].key != NULL)
+ _net_nfc_util_strdup(temp->tag_info_list[i].key, origin->tag_info_list[i].key);
- if (handle->tag_info_list[i].value != NULL)
+ if (origin->tag_info_list[i].value != NULL)
{
- data_s *data = (data_s *)handle->tag_info_list[i].value;
+ data_s *data = origin->tag_info_list[i].value;
net_nfc_create_data(&temp->tag_info_list[i].value, data->buffer, data->length);
}
}
}
- if (handle->raw_data.length > 0)
+ if (origin->raw_data.length > 0)
{
- net_nfc_util_alloc_data(&temp->raw_data, handle->raw_data.length);
- memcpy(temp->raw_data.buffer, handle->raw_data.buffer, temp->raw_data.length);
+ net_nfc_util_alloc_data(&temp->raw_data, origin->raw_data.length);
+ memcpy(temp->raw_data.buffer, origin->raw_data.buffer, temp->raw_data.length);
}
- *result = (net_nfc_target_info_h)temp;
+ *result = temp;
return NET_NFC_OK;
}
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_release_tag_info(net_nfc_target_info_h target_info)
+API net_nfc_error_e net_nfc_release_tag_info(net_nfc_target_info_s *target_info)
{
- net_nfc_target_info_s *info = (net_nfc_target_info_s *)target_info;
net_nfc_error_e result;
- if (info == NULL)
+ if (target_info == NULL)
return NET_NFC_NULL_PARAMETER;
- result = _release_tag_info(info);
+ result = _release_tag_info(target_info);
- _net_nfc_util_free_mem(info);
+ _net_nfc_util_free_mem(target_info);
return result;
}
g_free(func_data);
}
-API net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_h handle,
- data_h rawdata, nfc_transceive_callback callback, void *user_data)
+API net_nfc_error_e net_nfc_client_transceive(net_nfc_target_handle_s *handle,
+ data_s *rawdata, nfc_transceive_callback callback, void *user_data)
{
net_nfc_target_info_s *target_info;
NetNfcCallback *funcdata;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_transceive_data(net_nfc_target_handle_h handle,
- data_h rawdata, nfc_transceive_data_callback callback, void *user_data)
+API net_nfc_error_e net_nfc_client_transceive_data(net_nfc_target_handle_s *handle,
+ data_s *rawdata, nfc_transceive_data_callback callback, void *user_data)
{
net_nfc_target_info_s *target_info;
NetNfcCallback *funcdata;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_transceive_sync(net_nfc_target_handle_h handle,
- data_h rawdata)
+API net_nfc_error_e net_nfc_client_transceive_sync(net_nfc_target_handle_s *handle,
+ data_s *rawdata)
{
net_nfc_target_info_s *target_info;
net_nfc_error_e out_result = NET_NFC_OK;
}
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_target_handle_s *handle, data_s *rawdata, data_s **response)
{
net_nfc_target_info_s *target_info;
net_nfc_error_e out_result = NET_NFC_OK;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
+#include <glib.h>
/**
- NFC Manager
- NFC Manager controls the nfc device with high level APIs such as SmartPoster and Connection handover.
- It also support the JSR257 push handling.
- This file describe the structure and defines of the NFC manager
-
- @version 0.1
-
- */
+ NFC Manager
+ NFC Manager controls the nfc device with high level APIs such as SmartPoster and Connection handover.
+ It also support the JSR257 push handling.
+ This file describe the structure and defines of the NFC manager
+ */
/**
- @defgroup NET_NFC_MANAGER The description of NFC Manager
- @defgroup NET_NFC_TYPEDEF Defines and structures
- @defgroup NET_NFC_MANAGER_API NFC Manager
- @defgroup NET_NFC_MANAGER_INFO Tag Information and data APIs
- @defgroup NET_NFC_MANAGER_TAG Tag Read/Write APIs
- @defgroup NET_NFC_MANAGER_NDEF NDEF Message APIs
- @defgroup NET_NFC_MANAGER_RECORD NDEF Record APIs
- @defgroup NET_NFC_MANAGER_LLCP NFC LLCP APIs
- @defgroup NET_NFC_MANAGER_APDU Internal APDU APIs
- @defgroup NET_NFC_MANAGER_EXCHANGE App Exchanger APIs
-
-
- @addtogroup NET_NFC_MANAGER
- @{
- <P> "NFC Manager" is the framework that provide NFC APIs,
- and it also provide high level services such as Smart Poster, Connection Handover,
- and JSR257 push registry. </P>
-
- NFC Manager APIs are defined in <net_nfc.h>, <net_nfc_typedef.h>
-
- <P>
- Memory management rules <br>
- depends on the the verb of each function it describe memory management roles
-
- 1. set: copy the parameters and used inside of nfc-manager, you should free the parameter you have used
- 2. append: it is similar to "set" but, it does not make copy, you SHOULD NOT free the parameter after use it belongs to nfc-manager and it will be freed later
- (example "net_nfc_append_record_to_ndef_message") the appended record will be free the at the ndef message free time.
- 3. get, search : it gives original pointer to you, DO NOT free the pointer get from nfc-manager API
- 4. remove: automatically free inside of the this function do not free again.
- 5. create: it allocate handle, therefore, you should consider free after using (for example "net_nfc_create_rawdata_from_ndef_message(ndef_message_h ndef_message, data_h *rawdata)"
- this function allocate the data_h, you should free data with the function net_nfc_free_data())
- </p>
-
- @}
- */
+ @defgroup NET_NFC_MANAGER The description of NFC Manager
+ @defgroup NET_NFC_TYPEDEF Defines and structures
+ @defgroup NET_NFC_MANAGER_API NFC Manager
+ @defgroup NET_NFC_MANAGER_INFO Tag Information and data APIs
+ @defgroup NET_NFC_MANAGER_TAG Tag Read/Write APIs
+ @defgroup NET_NFC_MANAGER_NDEF NDEF Message APIs
+ @defgroup NET_NFC_MANAGER_RECORD NDEF Record APIs
+ @defgroup NET_NFC_MANAGER_LLCP NFC LLCP APIs
+ @defgroup NET_NFC_MANAGER_APDU Internal APDU APIs
+ @defgroup NET_NFC_MANAGER_EXCHANGE App Exchanger APIs
+
+
+ @addtogroup NET_NFC_MANAGER
+ @{
+ <P> "NFC Manager" is the framework that provide NFC APIs,
+ and it also provide high level services such as Smart Poster, Connection Handover,
+ and JSR257 push registry. </P>
+
+ NFC Manager APIs are defined in <net_nfc.h>, <net_nfc_typedef.h>
+
+ <P>
+ Memory management rules <br>
+ depends on the the verb of each function it describe memory management roles
+
+ 1. set: copy the parameters and used inside of nfc-manager, you should free the parameter you have used
+ 2. append: it is similar to "set" but, it does not make copy, you SHOULD NOT free the parameter after use it belongs to nfc-manager and it will be freed later
+ (example "net_nfc_append_record_to_ndef_message") the appended record will be free the at the ndef message free time.
+ 3. get, search : it gives original pointer to you, DO NOT free the pointer get from nfc-manager API
+ 4. remove: automatically free inside of the this function do not free again.
+ 5. create: it allocate handle, therefore, you should consider free after using
+ </p>
+
+ @}
+ */
/**
- @addtogroup NET_NFC_TYPEDEF
- @{
- This documents provide the NFC defines
+ @addtogroup NET_NFC_TYPEDEF
+ @{
+ This documents provide the NFC defines
- */
+*/
/**
- net_nfc_error_e is enum type that returned from each functions
- it mostly contains the error codes and it may contains status codes.
- */
+ net_nfc_error_e is enum type that returned from each functions
+ it mostly contains the error codes and it may contains status codes.
+ */
typedef enum
{
-/*000*/NET_NFC_OK = 0, /**< Status is OK */
-/*999*/NET_NFC_UNKNOWN_ERROR = -999, /**< Unknown error */
-/*998*/NET_NFC_ALLOC_FAIL, /**< Memory allocation is failed */
-/*997*/NET_NFC_THREAD_CREATE_FAIL, /**< Thread creation is failed */
-/*996*/NET_NFC_INVALID_STATE, /**< State of NFC-Manager or nfc-stack is not normal */
-/*995*/NET_NFC_IPC_FAIL, /**< Communication with ipc is failed. (from client to server)*/
-/*994*/NET_NFC_OUT_OF_BOUND, /**< Index is out of bound */
-/*993*/NET_NFC_NULL_PARAMETER, /**< Unexpected NULL parameter is received */
-/*992*/NET_NFC_BUFFER_TOO_SMALL, /**< Requested buffer is too small to store data, this error should be received */
-/*991*/NET_NFC_ALREADY_INITIALIZED, /**< You tried to initialized again without de-init */
-/*990*/NET_NFC_COMMUNICATE_WITH_CONTROLLER_FAILED, /**< Communication with Controller Chipset is failed this is Fatal Error */
-/*989*/NET_NFC_RF_TIMEOUT, /**< Timeout is raised while communicate with a tag */
-/*988*/NET_NFC_RF_ERROR, /**< Unexpected package is received from target, you may receive this error comes by the low level RF communication fault*/
-/*987*/NET_NFC_NOT_INITIALIZED, /**< Application tries to request without initialization */
-/*986*/NET_NFC_NOT_SUPPORTED, /**< Request information or command is not supported in current connected target */
-/*985*/NET_NFC_ALREADY_REGISTERED, /**< Requested SAP number is already used by other socket or data is already appended or registered */
-/*984*/NET_NFC_NOT_ALLOWED_OPERATION, /**< Requested Operation is not allowed in the situation in critical time (such as write data on target)*/
-/*983*/NET_NFC_BUSY, /**< Previous operation is not finished. don't worry to get this message, most of request will be executed in the serial queue */
-/*982*/NET_NFC_INVALID_HANDLE, /**< Requested Device in not valid device */
-/*981*/NET_NFC_TAG_READ_FAILED, /**< Tag reading is failed because of unexpected chunk data is received or error ack is received */
-/*980*/NET_NFC_TAG_WRITE_FAILED, /**< When you try to write on read only tag or error ack is received */
-/*979*/NET_NFC_NO_NDEF_SUPPORT, /**< Tag is not supported NDEF format for tag is not formatted for NDEF */
-/*978*/NET_NFC_NO_NDEF_MESSAGE, /**< No data is received after NDEF reading */
-/*977*/NET_NFC_INVALID_FORMAT, /**< Received data is not readable or it has illegal values or format */
-/*976*/NET_NFC_INSUFFICIENT_STORAGE, /**< The connected tag does not have enough information */
-/*975*/NET_NFC_OPERATION_FAIL, /**< The remote target returned error while doing a operation*/
-/*974*/NET_NFC_NOT_CONNECTED, /**< remote is not connected correctly. This can be happened when the RF does not have enough strength */
-/*973*/NET_NFC_NO_DATA_FOUND, /**< Requested data is not found in the list or properties */
-/*972*/NET_NFC_SECURITY_FAIL, /**< Authentication is failed while communication with nfc-manager server */
-/*971*/NET_NFC_TARGET_IS_MOVED_AWAY, /**< Target is lost while doing a operation */
-/*970*/NET_NFC_TAG_IS_ALREADY_FORMATTED, /** Target is already formatted */
-/*969*/NET_NFC_NOT_REGISTERED, /**< removal is requested but requested data is not registered */
-/*968*/NET_NFC_INVALID_PARAM, /**< removal is requested but requested data is not registered */
-/*499*/NET_NFC_NDEF_TYPE_LENGTH_IS_NOT_OK = -499, /**< Illegal ndef record type length */
-/*498*/NET_NFC_NDEF_PAYLOAD_LENGTH_IS_NOT_OK, /**< Illegal ndef record payload length */
-/*497*/NET_NFC_NDEF_ID_LENGTH_IS_NOT_OK, /**< Illegal ndef record id length */
-/*496*/NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE, /**< Parameter record is not expected record. for example, try to URI from text record */
-/*495*/NET_NFC_NDEF_BUF_END_WITHOUT_ME, /**< NDEF messages is terminated without ME flag */
-/*494*/NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC, /**< Current device does not support NFC feature or this manager does not found plugin library */
-
-/*399*/NET_NFC_LLCP_INVALID_SOCKET = -399, /**< socket is not valid socket */
-/*398*/NET_NFC_LLCP_SOCKET_DISCONNECTED, /**< socket is disconnected */
-/*397*/NET_NFC_LLCP_SOCKET_FRAME_REJECTED, /**< send data is rejected from remote side */
-
-/*299*/NET_NFC_P2P_SEND_FAIL = -299, /**< P2P data send fail */
+ /*000*/NET_NFC_OK = 0, /**< Status is OK */
+ /*999*/NET_NFC_UNKNOWN_ERROR = -999, /**< Unknown error */
+ /*998*/NET_NFC_ALLOC_FAIL, /**< Memory allocation is failed */
+ /*997*/NET_NFC_THREAD_CREATE_FAIL, /**< Thread creation is failed */
+ /*996*/NET_NFC_INVALID_STATE, /**< State of NFC-Manager or nfc-stack is not normal */
+ /*995*/NET_NFC_IPC_FAIL, /**< Communication with ipc is failed. (from client to server)*/
+ /*994*/NET_NFC_OUT_OF_BOUND, /**< Index is out of bound */
+ /*993*/NET_NFC_NULL_PARAMETER, /**< Unexpected NULL parameter is received */
+ /*992*/NET_NFC_BUFFER_TOO_SMALL, /**< Requested buffer is too small to store data, this error should be received */
+ /*991*/NET_NFC_ALREADY_INITIALIZED, /**< You tried to initialized again without de-init */
+ /*990*/NET_NFC_COMMUNICATE_WITH_CONTROLLER_FAILED, /**< Communication with Controller Chipset is failed this is Fatal Error */
+ /*989*/NET_NFC_RF_TIMEOUT, /**< Timeout is raised while communicate with a tag */
+ /*988*/NET_NFC_RF_ERROR, /**< Unexpected package is received from target, you may receive this error comes by the low level RF communication fault*/
+ /*987*/NET_NFC_NOT_INITIALIZED, /**< Application tries to request without initialization */
+ /*986*/NET_NFC_NOT_SUPPORTED, /**< Request information or command is not supported in current connected target */
+ /*985*/NET_NFC_ALREADY_REGISTERED, /**< Requested SAP number is already used by other socket or data is already appended or registered */
+ /*984*/NET_NFC_NOT_ALLOWED_OPERATION, /**< Requested Operation is not allowed in the situation in critical time (such as write data on target)*/
+ /*983*/NET_NFC_BUSY, /**< Previous operation is not finished. don't worry to get this message, most of request will be executed in the serial queue */
+ /*982*/NET_NFC_INVALID_HANDLE, /**< Requested Device in not valid device */
+ /*981*/NET_NFC_TAG_READ_FAILED, /**< Tag reading is failed because of unexpected chunk data is received or error ack is received */
+ /*980*/NET_NFC_TAG_WRITE_FAILED, /**< When you try to write on read only tag or error ack is received */
+ /*979*/NET_NFC_NO_NDEF_SUPPORT, /**< Tag is not supported NDEF format for tag is not formatted for NDEF */
+ /*978*/NET_NFC_NO_NDEF_MESSAGE, /**< No data is received after NDEF reading */
+ /*977*/NET_NFC_INVALID_FORMAT, /**< Received data is not readable or it has illegal values or format */
+ /*976*/NET_NFC_INSUFFICIENT_STORAGE, /**< The connected tag does not have enough information */
+ /*975*/NET_NFC_OPERATION_FAIL, /**< The remote target returned error while doing a operation*/
+ /*974*/NET_NFC_NOT_CONNECTED, /**< remote is not connected correctly. This can be happened when the RF does not have enough strength */
+ /*973*/NET_NFC_NO_DATA_FOUND, /**< Requested data is not found in the list or properties */
+ /*972*/NET_NFC_SECURITY_FAIL, /**< Authentication is failed while communication with nfc-manager server */
+ /*971*/NET_NFC_TARGET_IS_MOVED_AWAY, /**< Target is lost while doing a operation */
+ /*970*/NET_NFC_TAG_IS_ALREADY_FORMATTED, /** Target is already formatted */
+ /*969*/NET_NFC_NOT_REGISTERED, /**< removal is requested but requested data is not registered */
+ /*968*/NET_NFC_INVALID_PARAM, /**< removal is requested but requested data is not registered */
+ /*499*/NET_NFC_NDEF_TYPE_LENGTH_IS_NOT_OK = -499, /**< Illegal ndef record type length */
+ /*498*/NET_NFC_NDEF_PAYLOAD_LENGTH_IS_NOT_OK, /**< Illegal ndef record payload length */
+ /*497*/NET_NFC_NDEF_ID_LENGTH_IS_NOT_OK, /**< Illegal ndef record id length */
+ /*496*/NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE, /**< Parameter record is not expected record. for example, try to URI from text record */
+ /*495*/NET_NFC_NDEF_BUF_END_WITHOUT_ME, /**< NDEF messages is terminated without ME flag */
+ /*494*/NET_NFC_DEVICE_DOES_NOT_SUPPORT_NFC, /**< Current device does not support NFC feature or this manager does not found plugin library */
+
+ /*399*/NET_NFC_LLCP_INVALID_SOCKET = -399, /**< socket is not valid socket */
+ /*398*/NET_NFC_LLCP_SOCKET_DISCONNECTED, /**< socket is disconnected */
+ /*397*/NET_NFC_LLCP_SOCKET_FRAME_REJECTED, /**< send data is rejected from remote side */
+
+ /*299*/NET_NFC_P2P_SEND_FAIL = -299, /**< P2P data send fail */
} net_nfc_error_e;
/**
- Enum value of the record type ( TNF value )
- */
+ Enum value of the record type ( TNF value )
+ */
typedef enum
{
NET_NFC_RECORD_EMPTY = 0x0,
} net_nfc_record_tnf_e;
/**
- net_nfc_message_e is identify the events comes from nfc-manager.
- most of the events response event that you requested operations.
- and some of the events are generated by nfc-manager. (example, NET_NFC_MESSAGE_TAG_DISCOVERED, NET_NFC_MESSAGE_TAG_DETACHED,
- NET_NFC_MESSAGE_LLCP_DISCOVERED and NET_NFC_MESSAGE_LLCP_DETACHED)
+ net_nfc_message_e is identify the events comes from nfc-manager.
+ most of the events response event that you requested operations.
+ and some of the events are generated by nfc-manager. (example, NET_NFC_MESSAGE_TAG_DISCOVERED, NET_NFC_MESSAGE_TAG_DETACHED,
+ NET_NFC_MESSAGE_LLCP_DISCOVERED and NET_NFC_MESSAGE_LLCP_DETACHED)
- All of the events are delivered by the the callback function that registered with "net_nfc_set_response_callback"
- */
+ All of the events are delivered by the the callback function that registered with "net_nfc_set_response_callback"
+ */
typedef enum
{
NET_NFC_MESSAGE_TRANSCEIVE = 0, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_tranceive"
- <br> if the operation is success, the data parameter should cast into data_h or it return NULL*/
+ <br> if the operation is success, the data parameter should cast into data_s *or it return NULL*/
NET_NFC_MESSAGE_READ_NDEF, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_read_tag"
- <br> if the operation is success, the data parameter should cast into ndef_message_h or it return NULL */
+ <br> if the operation is success, the data parameter should cast into ndef_message_s* or it return NULL */
NET_NFC_MESSAGE_WRITE_NDEF, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_write_ndef"
- <br> data pointer always returns NULL */
+ <br> data pointer always returns NULL */
NET_NFC_MESSAGE_MAKE_READ_ONLY_NDEF, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_make_read_only_ndef"
- <br> data pointer always returns NULL */
+ <br> data pointer always returns NULL */
NET_NFC_MESSAGE_IS_TAG_CONNECTED, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_is_tag_conneced"
- <br> data pointer always returns NULL */
+ <br> data pointer always returns NULL */
NET_NFC_MESSAGE_GET_CURRENT_TAG_INFO, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_get_current_tag_infof"
- <br> if the operation is success, the data parameter should cast into net_nfc_target_info_h or it return NULL */
+ <br> if the operation is success, the data parameter should cast into net_nfc_target_info_s* or it return NULL */
NET_NFC_MESSAGE_GET_CURRENT_TARGET_HANDLE, /**< Type: Response Event, <br> This events is received after calling the "net_nfc_get_current_target_handle"
- <br> if the operation is success, the data parameter should cast into net_nfc_target_handle_h or it return NULL */
+ <br> if the operation is success, the data parameter should cast into net_nfc_target_handle_s* or it return NULL */
NET_NFC_MESSAGE_TAG_DISCOVERED, /**< Type: Notify Event, <br> When a tag or SE is detected, you got this event.
- <br> The data contains the target info , need to cast to net_nfc_target_info_h*/
+ <br> The data contains the target info , need to cast to net_nfc_target_info_s* */
NET_NFC_MESSAGE_NOTIFY, /**< This Notify Event <br> when the unexpected error has occurred, this event is delivered. data pointer always returns NULL */
NET_NFC_MESSAGE_TAG_DETACHED, /**< Type: Notify Event, <br> When a tag or SE is disappeared, you got this event.
- <br> The data contains the target info , need to cast to net_nfc_target_info_h but it does not have detail target info
- <br> please, do not use "net_nfc_get_tag_info_keys" when you got this event*/
-/*10*/ NET_NFC_MESSAGE_FORMAT_NDEF, /**< Type: Response Event <br> After complete "net_nfc_format_ndef", this event is delivered */
+ <br> The data contains the target info , need to cast to net_nfc_target_info_s* but it does not have detail target info
+ <br> please, do not use "net_nfc_get_tag_info_keys" when you got this event*/
+ /*10*/ NET_NFC_MESSAGE_FORMAT_NDEF, /**< Type: Response Event <br> After complete "net_nfc_format_ndef", this event is delivered */
NET_NFC_MESSAGE_LLCP_DISCOVERED,/**< Type: Notify Event <br> When LLCP is discovered and remote device is support llcp, you receive this event
- <br> data pointer contains the remote llcp configuration info. Cast to net_nfc_llcp_config_info_h*/
+ <br> data pointer contains the remote llcp configuration info. Cast to net_nfc_llcp_config_info_s* */
NET_NFC_MESSAGE_P2P_DETACHED, /**< Type: Notify Event <br> When LLCP is de-activated by removing the device, you receive this event*/
NET_NFC_MESSAGE_LLCP_CONFIG, /**< Type: Response Event. <br> The operation of "net_nfc_set_llcp_local_configure" is completed */
NET_NFC_MESSAGE_SE_START_TRANSACTION, /**< Type: Notify Event, indicates external reader start transaction*/
NET_NFC_MESSAGE_SE_END_TRANSACTION, /**< Type: Notify Event, indicates external reader end transaction*/
NET_NFC_MESSAGE_SE_TYPE_TRANSACTION, /**< Type: Notify Event, Indicates external reader trying to access secure element */
-/*20*/ NET_NFC_MESSAGE_SE_CONNECTIVITY, /**< Type: Notify Event, This event notifies the terminal host that it shall send a connectivity event from UICC */
+ /*20*/ NET_NFC_MESSAGE_SE_CONNECTIVITY, /**< Type: Notify Event, This event notifies the terminal host that it shall send a connectivity event from UICC */
NET_NFC_MESSAGE_SE_FIELD_ON, /**< Type: Notify Event, indicates external reader field is on*/
NET_NFC_MESSAGE_SE_FIELD_OFF, /**< Type: Notify Event, indicates external reader field is off*/
NET_NFC_MESSAGE_SE_TYPE_CHANGED, /**< Type: Notify Event, indicates secure element type is changed*/
NET_NFC_MESSAGE_OPEN_INTERNAL_SE,
NET_NFC_MESSAGE_CLOSE_INTERNAL_SE,
NET_NFC_MESSAGE_SEND_APDU_SE,
-/*30*/ NET_NFC_MESSAGE_GET_ATR_SE,
+ /*30*/ NET_NFC_MESSAGE_GET_ATR_SE,
NET_NFC_GET_SERVER_STATE,
NET_NFC_MESSAGE_SIM_TEST,
NET_NFC_MESSAGE_SNEP_START_SERVER,
NET_NFC_MESSAGE_SNEP_START_CLIENT,
-/*40*/ NET_NFC_MESSAGE_SNEP_REQUEST,
+ /*40*/ NET_NFC_MESSAGE_SNEP_REQUEST,
NET_NFC_MESSAGE_SNEP_STOP_SERVICE,
NET_NFC_MESSAGE_SNEP_REGISTER_SERVER,
NET_NFC_MESSAGE_SNEP_UNREGISTER_SERVER,
/**
- Card states for nfc tag
- */
+ Card states for nfc tag
+ */
typedef enum
{
NET_NFC_NDEF_CARD_INVALID = 0x00, /**< The card is not NFC forum specified tag. The ndef format will be needed. */
} net_nfc_ndef_card_state_e;
/**
- Encoding type for string message
- */
+ Encoding type for string message
+ */
typedef enum
{
NET_NFC_ENCODE_UTF_8 = 0x00,
} net_nfc_encode_type_e;
/**
- URI scheme type defined in the NFC forum "URI Record Type Definition"
- */
+ URI scheme type defined in the NFC forum "URI Record Type Definition"
+ */
typedef enum
{
NET_NFC_SCHEMA_FULL_URI = 0x00, /**< protocol is specify by payload */
**************************************
*/
/**
- These events are delivered to the each socket callback. These events are separated events that comes from "net_nfc_set_response_callback" callback
- */
+ These events are delivered to the each socket callback. These events are separated events that comes from "net_nfc_set_response_callback" callback
+ */
typedef enum
{
/* start number should be larger than "net_nfc_message_e"
- because to make seperate with net_nfc_message_e event it may conflict in
- the dispatcher and ipc part */
+ because to make seperate with net_nfc_message_e event it may conflict in
+ the dispatcher and ipc part */
NET_NFC_MESSAGE_LLCP_LISTEN = 1000, /**< Type: Response Event <br> this event indicates "net_nfc_listen_llcp" requested is completed*/
NET_NFC_MESSAGE_LLCP_ACCEPTED, /**< Type: Notify Event. <br> Remote socket is accepted to listening socket
- <br> data pointer contains the remote socket info (Cast to net_nfc_llcp_socket_option_h)*/
+ <br> data pointer contains the remote socket info (Cast to net_nfc_llcp_socket_option_s*)*/
NET_NFC_MESSAGE_LLCP_CONNECT, /**< Type: Response Event. <br> "net_nfc_connect_llcp_with" request is completed and your socket is connected to remote site with url*/
NET_NFC_MESSAGE_LLCP_CONNECT_SAP, /**< Type: Response Event.<br> "net_nfc_connect_llcp_with_sap" request is completed and your socket is connected to remote site with sap number*/
NET_NFC_MESSAGE_LLCP_SEND, /**< Type: Response Event,<br> "net_nfc_send_llcp" operation is completed (connection mode)*/
NET_NFC_MESSAGE_LLCP_SEND_TO, /**< Type: Response Event,<br> "net_nfc_send_llcp_to"operation is completed (connectionless mode)*/
NET_NFC_MESSAGE_LLCP_RECEIVE, /**< Type: Response Event,<br> "net_nfc_receive_llcp" operation is completed (connection mode)
- <br> data pointer contains received data (Cast to data_h)*/
+ <br> data pointer contains received data (Cast to data_s*)*/
NET_NFC_MESSAGE_LLCP_RECEIVE_FROM, /**< Type: Response Event,<br> "net_nfc_receive_llcp_from" operation is completed (connectionless mode)*/
NET_NFC_MESSAGE_LLCP_DISCONNECT, /**< Type: Response Event,<br> "net_nfc_disconnect_llcp" request is completed */
NET_NFC_MESSAGE_LLCP_ERROR, /**< Type: Notify Event,<br> when the socket is disconnected, you may receive this event */
NET_NFC_NPP,
} llcp_app_protocol_e;
-typedef struct _data_s *data_h;
+typedef enum
+{
+ NET_NFC_TAG_CONNECTION = 0x00,
+ NET_NFC_P2P_CONNECTION_TARGET,
+ NET_NFC_P2P_CONNECTION_INITIATOR,
+ NET_NFC_SE_CONNECTION
+} net_nfc_connection_type_e;
+
+typedef enum
+{
+ NET_NFC_CONN_HANDOVER_CARRIER_BT = 0x00,
+ NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS, /* infrastructure */
+ NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS, /* add hoc */
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+} net_nfc_conn_handover_carrier_type_e;
-typedef struct _ndef_record_s *ndef_record_h;
+/**
+ This structure is just data, to express bytes array
+ */
+typedef struct
+{
+ uint8_t *buffer;
+ uint32_t length;
+} data_s;
-typedef struct _ndef_message_s *ndef_message_h;
+/**
+ ndef_record_s structure has the NDEF record data. it is only a record not a message
+ */
+typedef struct _ndef_record_s
+{
+ uint8_t MB :1;
+ uint8_t ME :1;
+ uint8_t CF :1;
+ uint8_t SR :1;
+ uint8_t IL :1;
+ uint8_t TNF :3;
+ data_s type_s;
+ data_s id_s;
+ data_s payload_s;
+ struct _ndef_record_s *next;
+}ndef_record_s;
-typedef struct _net_nfc_target_info_s *net_nfc_target_info_h;
+/**
+ NDEF message it has record counts and records (linked listed form)
+ */
+typedef struct _ndef_message_s
+{
+ uint32_t recordCount;
+ ndef_record_s *records; // linked list
+} ndef_message_s;
-typedef struct _net_nfc_llcp_config_info_s *net_nfc_llcp_config_info_h;
+typedef struct _net_nfc_target_handle_s
+{
+ uint32_t connection_id;
+ net_nfc_connection_type_e connection_type;
+ net_nfc_target_type_e target_type;
+ /*++npp++*/
+ llcp_app_protocol_e app_type;
+ /*--npp--*/
+}net_nfc_target_handle_s;
+
+typedef struct _net_nfc_tag_info_s
+{
+ char *key;
+ data_s *value;
+} net_nfc_tag_info_s;
-typedef struct _net_nfc_llcp_socket_option_s *net_nfc_llcp_socket_option_h;
+typedef struct _net_nfc_target_info_s
+{
+ net_nfc_target_handle_s *handle;
+ net_nfc_target_type_e devType;
+ uint8_t is_ndef_supported;
+ uint8_t ndefCardState;
+ uint32_t maxDataSize;
+ uint32_t actualDataSize;
+ int number_of_keys;
+ net_nfc_tag_info_s *tag_info_list;
+ char **keylist;
+ data_s raw_data;
+}net_nfc_target_info_s;
+
+typedef struct _net_nfc_llcp_config_info_s
+{
+ uint16_t miu; /** The remote Maximum Information Unit (NOTE: this is MIU, not MIUX !)*/
+ uint16_t wks; /** The remote Well-Known Services*/
+ uint8_t lto; /** The remote Link TimeOut (in 1/100s)*/
+ uint8_t option; /** The remote options*/
+}net_nfc_llcp_config_info_s;
-typedef struct _net_nfc_target_handle_s *net_nfc_target_handle_h;
+typedef struct _net_nfc_llcp_socket_option_s
+{
+ uint16_t miu; /** The remote Maximum Information Unit */
+ uint8_t rw; /** The Receive Window size (4 bits)*/
+ net_nfc_socket_type_e type;
+}net_nfc_llcp_socket_option_s;
-typedef struct _net_nfc_connection_handover_info_s *net_nfc_connection_handover_info_h;
+typedef struct _net_nfc_connection_handover_info_s
+{
+ net_nfc_conn_handover_carrier_type_e type;
+ data_s data;
+}net_nfc_connection_handover_info_s;
typedef uint8_t sap_t;
typedef enum
{
- NET_NFC_CONN_HANDOVER_CARRIER_BT = 0x00,
- NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS, /* infrastructure */
- NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS, /* add hoc */
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
-} net_nfc_conn_handover_carrier_type_e;
-
-typedef enum
-{
NET_NFC_CONN_HANDOVER_CARRIER_INACTIVATE = 0x00,
NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE,
NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATING,
} net_nfc_felica_poll_request_code_e;
/**
- WIFI configuration key enums for connection handover.
- */
+ WIFI configuration key enums for connection handover.
+ */
typedef enum
{
NET_NFC_BT_ATTRIBUTE_ADDRESS = 0xF0, /* Bluetooth device Address */
} net_nfc_handover_bt_attribute_e;
-typedef struct _net_nfc_carrier_config_s *net_nfc_carrier_config_h;
-typedef struct _net_nfc_carrier_property_s *net_nfc_property_group_h;
+typedef struct _net_nfc_carrier_config_s
+{
+ net_nfc_conn_handover_carrier_type_e type;
+ int length;
+ GList *data;
+} net_nfc_carrier_config_s;
+
+/* WIFI Info */
+typedef struct _net_nfc_carrier_property_s
+{
+ bool is_group;
+ uint16_t attribute;
+ uint16_t length;
+ void *data;
+} net_nfc_carrier_property_s;
typedef enum
{
NET_NFC_LLCP_UNREGISTERED = -2,
NET_NFC_LLCP_START = -3,
NET_NFC_LLCP_STOP = -4,
-}
-net_nfc_llcp_state_t;
+}net_nfc_llcp_state_t;
typedef enum
{
NET_NFC_CARD_EMELATION_ENABLE = 0,
NET_NFC_CARD_EMULATION_DISABLE,
-}
-net_nfc_card_emulation_mode_t;
+}net_nfc_card_emulation_mode_t;
-typedef enum _net_nfc_launch_popup_state_e
+typedef enum
{
NET_NFC_NO_LAUNCH_APP_SELECT = 0,
NET_NFC_LAUNCH_APP_SELECT,
} net_nfc_launch_popup_state_e;
/**
- @}
- */
+ @}
+ */
#endif //__NET_NFC_TYPEDEF_H__
NET_NFC_POLL_STOP,
} net_nfc_detect_mode_e;
-/**
- This structure is just data, to express bytes array
- */
-typedef struct _data_s
-{
- uint8_t *buffer;
- uint32_t length;
-} data_s;
-
-typedef struct _net_nfc_data_t
-{
- uint32_t length;
- uint8_t buffer[0];
-} net_nfc_data_s;
-
-typedef enum _net_nfc_connection_type_e
-{
- NET_NFC_TAG_CONNECTION = 0x00,
- NET_NFC_P2P_CONNECTION_TARGET,
- NET_NFC_P2P_CONNECTION_INITIATOR,
- NET_NFC_SE_CONNECTION
-} net_nfc_connection_type_e;
-
-typedef struct _net_nfc_target_handle_s
-{
- uint32_t connection_id;
- net_nfc_connection_type_e connection_type;
- net_nfc_target_type_e target_type;
- /*++npp++*/
- llcp_app_protocol_e app_type;
- /*--npp--*/
-} net_nfc_target_handle_s;
-
typedef struct _net_nfc_current_target_info_s
{
net_nfc_target_handle_s *handle;
uint32_t devType;
int number_of_keys;
- net_nfc_data_s target_info_values;
+ data_s target_info_values;
}net_nfc_current_target_info_s;
-typedef struct _net_nfc_llcp_config_info_s
-{
- uint16_t miu; /** The remote Maximum Information Unit (NOTE: this is MIU, not MIUX !)*/
- uint16_t wks; /** The remote Well-Known Services*/
- uint8_t lto; /** The remote Link TimeOut (in 1/100s)*/
- uint8_t option; /** The remote options*/
-} net_nfc_llcp_config_info_s;
-
-typedef struct _net_nfc_llcp_socket_option_s
-{
- uint16_t miu; /** The remote Maximum Information Unit */
- uint8_t rw; /** The Receive Window size (4 bits)*/
- net_nfc_socket_type_e type;
-} net_nfc_llcp_socket_option_s;
-
typedef struct _net_nfc_llcp_internal_socket_s
{
uint16_t miu; /** The remote Maximum Information Unit */
} net_nfc_llcp_internal_socket_s;
/**
- ndef_record_s structure has the NDEF record data. it is only a record not a message
- */
-typedef struct _record_s
-{
- uint8_t MB :1;
- uint8_t ME :1;
- uint8_t CF :1;
- uint8_t SR :1;
- uint8_t IL :1;
- uint8_t TNF :3;
- data_s type_s;
- data_s id_s;
- data_s payload_s;
- struct _record_s *next;
-} ndef_record_s;
-
-/**
- NDEF message it has record counts and records (linked listed form)
- */
-typedef struct _ndef_message_s
-{
- uint32_t recordCount;
- ndef_record_s *records; // linked list
-} ndef_message_s;
-
-/**
Enum value to stop or start the discovery mode
*/
net_nfc_sIso15693Info_t Iso15693_Info;
} net_nfc_remoteDevInfo_t;
-typedef struct _net_nfc_tag_info_s
-{
- char *key;
- data_h value;
-} net_nfc_tag_info_s;
-
-typedef struct _net_nfc_target_info_s
-{
- net_nfc_target_handle_s *handle;
- net_nfc_target_type_e devType;
- uint8_t is_ndef_supported;
- uint8_t ndefCardState;
- uint32_t maxDataSize;
- uint32_t actualDataSize;
- int number_of_keys;
- net_nfc_tag_info_s *tag_info_list;
- char **keylist;
- data_s raw_data;
-} net_nfc_target_info_s;
-
typedef struct _net_nfc_se_event_info_s
{
data_s aid;
data_s trans_data;
} net_nfc_transceive_info_s;
-typedef struct _net_nfc_connection_handover_info_s
-{
- net_nfc_conn_handover_carrier_type_e type;
- data_s data;
-}
-net_nfc_connection_handover_info_s;
-
-typedef enum _client_state_e
+typedef enum
{
NET_NFC_CLIENT_INACTIVE_STATE = 0x00,
NET_NFC_CLIENT_ACTIVE_STATE,
} client_state_e;
-typedef enum _net_nfc_launch_popup_check_e
+typedef enum
{
CHECK_FOREGROUND = 0x00,
NO_CHECK_FOREGROUND,
typedef struct _net_nfc_request_msg_t
{
- NET_NFC_REQUEST_MSG_HEADER
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
} net_nfc_request_msg_t;
typedef struct _net_nfc_request_target_detected_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
net_nfc_target_handle_s *handle;
uint32_t devType;
int number_of_keys;
- net_nfc_data_s target_info_values;
+ data_s target_info_values;
} net_nfc_request_target_detected_t;
typedef struct _net_nfc_request_se_event_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
data_s aid;
data_s param;
typedef struct _net_nfc_request_llcp_msg_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
uint32_t result;
net_nfc_llcp_socket_t llcp_socket;
typedef struct _net_nfc_request_listen_socket_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
uint32_t result;
net_nfc_target_handle_s *handle;
net_nfc_llcp_socket_t oal_socket;
sap_t sap;
void *trans_param;
- net_nfc_data_s service_name;
+ data_s service_name;
} net_nfc_request_listen_socket_t;
typedef struct _net_nfc_request_receive_socket_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
uint32_t result;
net_nfc_target_handle_s *handle;
net_nfc_llcp_socket_t oal_socket;
size_t req_length;
void *trans_param;
- net_nfc_data_s data;
+ data_s data;
} net_nfc_request_receive_socket_t;
typedef struct _net_nfc_request_receive_from_socket_t
{
- NET_NFC_REQUEST_MSG_HEADER;
+ uint32_t length;
+ uint32_t request_type;
+ uint32_t client_fd;
+ uint32_t flags;
+ uint32_t user_param;
+ // TODO: above value MUST be same with NET_NFC_REQUEST_MSG_HEADER
uint32_t result;
net_nfc_target_handle_s *handle;
size_t req_length;
sap_t sap;
void *trans_param;
- net_nfc_data_s data;
+ data_s data;
} net_nfc_request_receive_from_socket_t;
-// these are messages for response
-
typedef void (*target_detection_listener_cb)(void *data, void *user_param);
typedef void (*se_transaction_listener_cb)(void *data, void *user_param);
typedef void (*llcp_event_listener_cb)(void *data, void *user_param);
{
SECURE_ELEMENT_ACTIVE_STATE = 0x00, /**< state of the SE is active */
SECURE_ELEMENT_INACTIVE_STATE = 0x01 /**< state of the SE is In active*/
-
} net_nfc_secure_element_state_e;
typedef struct _secure_element_info_s
NET_NFC_CONN_HANDOVER_ERR_REASON_CARRIER_SPECIFIC_CONSTRAINT,
} net_nfc_conn_handover_error_reason_e;
-/* WIFI Info */
-typedef struct _net_nfc_carrier_property_s
-{
- bool is_group;
- uint16_t attribute;
- uint16_t length;
- void *data;
-} net_nfc_carrier_property_s;
-
-typedef struct _net_nfc_carrier_config_s
-{
- net_nfc_conn_handover_carrier_type_e type;
- int length;
- struct _GList *data;
-} net_nfc_carrier_config_s;
-
typedef struct _net_nfc_sub_field_s
{
uint16_t length;
uint8_t value[0];
-}
-__attribute__((packed)) net_nfc_sub_field_s;
+}__attribute__((packed)) net_nfc_sub_field_s;
typedef struct _net_nfc_signature_record_s
{
uint8_t sign_type : 7;
uint8_t uri_present : 1;
net_nfc_sub_field_s signature;
-}
-__attribute__((packed)) net_nfc_signature_record_s;
+}__attribute__((packed)) net_nfc_signature_record_s;
typedef struct _net_nfc_certificate_chain_s
{
uint8_t cert_format : 3;
uint8_t uri_present : 1;
uint8_t cert_store[0];
-}
-__attribute__((packed)) net_nfc_certificate_chain_s;
+}__attribute__((packed)) net_nfc_certificate_chain_s;
#define SMART_POSTER_RECORD_TYPE "Sp"
#define URI_RECORD_TYPE "U"
net_nfc_service_llcp_cb cb;
data_s data;
void *user_param;
-}
-net_nfc_llcp_param_t;
+}net_nfc_llcp_param_t;
#endif //__NET_NFC_TYPEDEF_INTERNAL_H__
void net_nfc_convert_byte_order(unsigned char *array, int size);
-net_nfc_error_e net_nfc_util_create_carrier_config(net_nfc_carrier_config_s **config, net_nfc_conn_handover_carrier_type_e type);
+net_nfc_error_e net_nfc_util_create_carrier_config(
+ net_nfc_carrier_config_s **config,
+ net_nfc_conn_handover_carrier_type_e type);
-net_nfc_error_e net_nfc_util_add_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data);
+net_nfc_error_e net_nfc_util_add_carrier_config_property(
+ net_nfc_carrier_config_s *config,
+ uint16_t attribute,
+ uint16_t size,
+ uint8_t *data);
-net_nfc_error_e net_nfc_util_remove_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute);
+net_nfc_error_e net_nfc_util_remove_carrier_config_property(
+ net_nfc_carrier_config_s *config, uint16_t attribute);
-net_nfc_error_e net_nfc_util_get_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t *size, uint8_t **data);
+net_nfc_error_e net_nfc_util_get_carrier_config_property(
+ net_nfc_carrier_config_s *config,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data);
-net_nfc_error_e net_nfc_util_append_carrier_config_group(net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
+net_nfc_error_e net_nfc_util_append_carrier_config_group(
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
-net_nfc_error_e net_nfc_util_remove_carrier_config_group(net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
+net_nfc_error_e net_nfc_util_remove_carrier_config_group(
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group);
-net_nfc_error_e net_nfc_util_get_carrier_config_group(net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group);
+net_nfc_error_e net_nfc_util_get_carrier_config_group(
+ net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group);
net_nfc_error_e net_nfc_util_free_carrier_config(net_nfc_carrier_config_s *config);
-net_nfc_error_e net_nfc_util_create_carrier_config_group(net_nfc_carrier_property_s **group, uint16_t attribute);
+net_nfc_error_e net_nfc_util_create_carrier_config_group(
+ net_nfc_carrier_property_s **group, uint16_t attribute);
-net_nfc_error_e net_nfc_util_add_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t size, uint8_t *data);
+net_nfc_error_e net_nfc_util_add_carrier_config_group_property(
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t size,
+ uint8_t *data);
-net_nfc_error_e net_nfc_util_get_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t *size, uint8_t **data);
+net_nfc_error_e net_nfc_util_get_carrier_config_group_property(
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data);
-net_nfc_error_e net_nfc_util_remove_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute);
+net_nfc_error_e net_nfc_util_remove_carrier_config_group_property(
+ net_nfc_carrier_property_s *group, uint16_t attribute);
net_nfc_error_e net_nfc_util_free_carrier_group(net_nfc_carrier_property_s *group);
-net_nfc_error_e net_nfc_util_create_ndef_record_with_carrier_config(ndef_record_s **record, net_nfc_carrier_config_s *config);
+net_nfc_error_e net_nfc_util_create_ndef_record_with_carrier_config(
+ ndef_record_s **record, net_nfc_carrier_config_s *config);
-net_nfc_error_e net_nfc_util_create_carrier_config_from_config_record(net_nfc_carrier_config_s **config, ndef_record_s *record);
+net_nfc_error_e net_nfc_util_create_carrier_config_from_config_record(
+ net_nfc_carrier_config_s **config, ndef_record_s *record);
-net_nfc_error_e net_nfc_util_append_carrier_config_record(ndef_message_s *message, ndef_record_s *record, net_nfc_conn_handover_carrier_state_e power_status);
+net_nfc_error_e net_nfc_util_append_carrier_config_record(
+ ndef_message_s *message,
+ ndef_record_s *record,
+ net_nfc_conn_handover_carrier_state_e power_status);
-net_nfc_error_e net_nfc_util_remove_carrier_config_record(ndef_message_s *message, ndef_record_s *record);
+net_nfc_error_e net_nfc_util_remove_carrier_config_record(
+ ndef_message_s *message, ndef_record_s *record);
-net_nfc_error_e net_nfc_util_get_carrier_config_record(ndef_message_s *message, int index, ndef_record_s **record);
+net_nfc_error_e net_nfc_util_get_carrier_config_record(ndef_message_s *message,
+ int index, ndef_record_s **record);
-net_nfc_error_e net_nfc_util_get_handover_random_number(ndef_message_s *message, unsigned short *random_number);
+net_nfc_error_e net_nfc_util_get_handover_random_number(
+ ndef_message_s *message, unsigned short *random_number);
-net_nfc_error_e net_nfc_util_get_alternative_carrier_record_count(ndef_message_s *message, unsigned int *count);
+net_nfc_error_e net_nfc_util_get_alternative_carrier_record_count(
+ ndef_message_s *message, unsigned int *count);
-net_nfc_error_e net_nfc_util_get_alternative_carrier_power_status(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_state_e *power_state);
+net_nfc_error_e net_nfc_util_get_alternative_carrier_power_status(
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e *power_state);
-net_nfc_error_e net_nfc_util_set_alternative_carrier_power_status(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_state_e power_status);
+net_nfc_error_e net_nfc_util_set_alternative_carrier_power_status(
+ ndef_message_s *message,
+ int index,
+ net_nfc_conn_handover_carrier_state_e power_status);
-net_nfc_error_e net_nfc_util_get_alternative_carrier_type_from_record(ndef_record_s *record, net_nfc_conn_handover_carrier_type_e *type);
+net_nfc_error_e net_nfc_util_get_alternative_carrier_type_from_record(
+ ndef_record_s *record, net_nfc_conn_handover_carrier_type_e *type);
/**
this function will get carrier type.
- @param[in] carrier_info connection handover carrier info handler
- @param[in] carrier_type record type. it can be a NET_NFC_CONN_HANDOVER_CARRIER_BT or NET_NFC_CONN_HANDOVER_CARRIER_WIFI or NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN.
+ @param[in] carrier_info connection handover carrier info handler
+ @param[in] carrier_type record type. it can be a NET_NFC_CONN_HANDOVER_CARRIER_BT or NET_NFC_CONN_HANDOVER_CARRIER_WIFI or NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN.
@return return the result of the calling the function
@exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
- */
-net_nfc_error_e net_nfc_util_get_alternative_carrier_type(ndef_message_s *message, int index, net_nfc_conn_handover_carrier_type_e *power_state);
+ */
+net_nfc_error_e net_nfc_util_get_alternative_carrier_type(ndef_message_s *message,
+ int index, net_nfc_conn_handover_carrier_type_e *power_state);
-net_nfc_error_e net_nfc_util_create_handover_request_message(ndef_message_s **message);
+net_nfc_error_e net_nfc_util_create_handover_request_message(
+ ndef_message_s **message);
-net_nfc_error_e net_nfc_util_create_handover_select_message(ndef_message_s **message);
+net_nfc_error_e net_nfc_util_create_handover_select_message(
+ ndef_message_s **message);
-net_nfc_error_e net_nfc_util_create_handover_carrier_record(ndef_record_s ** record);
-net_nfc_error_e net_nfc_util_create_handover_error_record(ndef_record_s **record, uint8_t reason, uint32_t data);
+net_nfc_error_e net_nfc_util_create_handover_carrier_record(
+ ndef_record_s **record);
+net_nfc_error_e net_nfc_util_create_handover_error_record(
+ ndef_record_s **record, uint8_t reason, uint32_t data);
-net_nfc_error_e net_nfc_util_get_selector_power_status(ndef_message_s *message, net_nfc_conn_handover_carrier_state_e *power_state);
+net_nfc_error_e net_nfc_util_get_selector_power_status(ndef_message_s *message,
+ net_nfc_conn_handover_carrier_state_e *power_state);
#endif //__NET_NFC_UTIL_HANDOVER_H__
return true;
}
-API bool net_nfc_util_duplicate_data(data_s *dest, net_nfc_data_s *src)
-{
- if (dest == NULL || src == NULL || src->length == 0)
- return false;
-
- if (net_nfc_util_alloc_data(dest, src->length) == false)
- return false;
-
- memcpy(dest->buffer, src->buffer, dest->length);
-
- return true;
-}
-
API void net_nfc_util_free_data(data_s *data)
{
if (data == NULL || data->buffer == NULL)
static int __property_equal_to(gconstpointer key1, gconstpointer key2)
{
- net_nfc_carrier_property_s *arg1 = (net_nfc_carrier_property_s *)key1;
- net_nfc_carrier_property_s *arg2 = (net_nfc_carrier_property_s *)key2;
+ const net_nfc_carrier_property_s *arg1 = key1;
+ const net_nfc_carrier_property_s *arg2 = key2;
if (arg1->attribute < arg2->attribute)
{
static void __find_nth_group(gpointer data, gpointer user_data)
{
- net_nfc_carrier_property_s *info = (net_nfc_carrier_property_s *)data;
- search_index *nth = (search_index *)user_data;
+ net_nfc_carrier_property_s *info = data;
+ search_index *nth = user_data;
if (info == NULL || user_data == NULL)
return;
static void __free_all_data(gpointer data, gpointer user_data)
{
- net_nfc_carrier_property_s *info = (net_nfc_carrier_property_s *)data;
+ net_nfc_carrier_property_s *info = data;
if (info == NULL)
return;
if (info->is_group)
{
NFC_DBG("FREE: group is found");
- net_nfc_util_free_carrier_group((net_nfc_carrier_property_s *)info);
+ net_nfc_util_free_carrier_group(info);
}
else
{
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_add_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t * data)
+net_nfc_error_e net_nfc_util_add_carrier_config_property(
+ net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t size, uint8_t *data)
{
net_nfc_carrier_property_s *elem = NULL;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_remove_carrier_config_property(net_nfc_carrier_config_s *config, uint16_t attribute)
+net_nfc_error_e net_nfc_util_remove_carrier_config_property(
+ net_nfc_carrier_config_s *config, uint16_t attribute)
{
net_nfc_carrier_property_s *elem = NULL;
if (elem->is_group)
{
- net_nfc_util_free_carrier_group((net_nfc_carrier_property_s *)elem);
+ net_nfc_util_free_carrier_group(elem);
}
else
{
}
net_nfc_error_e net_nfc_util_get_carrier_config_property(
- net_nfc_carrier_config_s *config, uint16_t attribute, uint16_t *size, uint8_t **data)
+ net_nfc_carrier_config_s *config,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data)
{
net_nfc_carrier_property_s *elem = NULL;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_remove_carrier_config_group(net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
+net_nfc_error_e net_nfc_util_remove_carrier_config_group(
+ net_nfc_carrier_config_s *config, net_nfc_carrier_property_s *group)
{
if (config == NULL || group == NULL)
{
config->length -= group->length;
config->data = g_list_remove(config->data, group);
- net_nfc_util_free_carrier_group((net_nfc_carrier_property_s *)group);
+ net_nfc_util_free_carrier_group(group);
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_get_carrier_config_group(net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group)
+net_nfc_error_e net_nfc_util_get_carrier_config_group(
+ net_nfc_carrier_config_s *config, int index, net_nfc_carrier_property_s **group)
{
search_index result;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_create_carrier_config_group(net_nfc_carrier_property_s **group, uint16_t attribute)
+net_nfc_error_e net_nfc_util_create_carrier_config_group(
+ net_nfc_carrier_property_s **group, uint16_t attribute)
{
if (group == NULL)
{
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_add_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t size, uint8_t *data)
+net_nfc_error_e net_nfc_util_add_carrier_config_group_property(
+ net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t size, uint8_t *data)
{
net_nfc_carrier_property_s *elem = NULL;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_get_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute, uint16_t *size, uint8_t ** data)
+net_nfc_error_e net_nfc_util_get_carrier_config_group_property(
+ net_nfc_carrier_property_s *group,
+ uint16_t attribute,
+ uint16_t *size,
+ uint8_t **data)
{
net_nfc_carrier_property_s *elem = NULL;
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_remove_carrier_config_group_property(net_nfc_carrier_property_s *group, uint16_t attribute)
+net_nfc_error_e net_nfc_util_remove_carrier_config_group_property(
+ net_nfc_carrier_property_s *group, uint16_t attribute)
{
net_nfc_carrier_property_s *elem = NULL;
static void __make_serial_wifi(gpointer data, gpointer user_data)
{
- net_nfc_carrier_property_s *info = (net_nfc_carrier_property_s *)data;
+ net_nfc_carrier_property_s *info = data;
data_s *payload = user_data;
uint8_t *current;
int inc = 0;
static void __make_serial_bt(gpointer data, gpointer user_data)
{
- net_nfc_carrier_property_s *info = (net_nfc_carrier_property_s *)data;
+ net_nfc_carrier_property_s *info = data;
data_s *payload = user_data;
uint8_t *current;
int inc = 0;
}
}
-net_nfc_error_e net_nfc_util_create_ndef_record_with_carrier_config(ndef_record_s **record, net_nfc_carrier_config_s *config)
+net_nfc_error_e net_nfc_util_create_ndef_record_with_carrier_config(
+ ndef_record_s **record, net_nfc_carrier_config_s *config)
{
data_s payload = { NULL, 0 };
data_s record_type = { NULL, 0 };
return NET_NFC_OK;
}
-net_nfc_error_e net_nfc_util_create_carrier_config_from_config_record(net_nfc_carrier_config_s **config, ndef_record_s *record)
+net_nfc_error_e net_nfc_util_create_carrier_config_from_config_record(
+ net_nfc_carrier_config_s **config, ndef_record_s *record)
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_conn_handover_carrier_type_e type;
{
*type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
}
- break;
+ break;
case NET_NFC_RECORD_WELL_KNOWN_TYPE: /* NFC Forum Well-known Type*/
case NET_NFC_RECORD_URI: /* Absolute URIs as defined in [RFC 3986] */
case NET_NFC_RECORD_EXTERNAL_RTD: /* NFC Forum external type */
{
NFC_DBG("Other record type");
if (strncmp((char *)record->type_s.buffer, CONN_HANDOVER_BT_CARRIER_MIME_NAME,
- (size_t)record->type_s.length) == 0)
+ (size_t)record->type_s.length) == 0)
{
*type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
}
else if (strncmp((char *)record->type_s.buffer,
- CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,
- (size_t)record->type_s.length) == 0)
+ CONN_HANDOVER_WIFI_BSS_CARRIER_MIME_NAME,
+ (size_t)record->type_s.length) == 0)
{
*type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
}
else if (strncmp((char *)record->type_s.buffer,
- CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME,
+ CONN_HANDOVER_WIFI_IBSS_CARRIER_MIME_NAME,
(size_t)record->type_s.length) == 0)
{
*type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_IBSS;
}
net_nfc_error_e net_nfc_util_get_alternative_carrier_type(ndef_message_s *message,
- int index, net_nfc_conn_handover_carrier_type_e *type)
+ int index, net_nfc_conn_handover_carrier_type_e *type)
{
ndef_record_s *record = NULL;
net_nfc_error_e ret;
}
net_nfc_error_e net_nfc_util_get_selector_power_status(ndef_message_s *message,
- net_nfc_conn_handover_carrier_state_e *power_state)
+ net_nfc_conn_handover_carrier_state_e *power_state)
{
net_nfc_error_e error;
ndef_message_s *inner_msg = NULL;
for (idx = 0; idx < inner_msg->recordCount; idx++)
{
if (strncmp((char *)current->type_s.buffer, ALTERNATIVE_RECORD_TYPE,
- (size_t)current->type_s.length) == 0)
+ (size_t)current->type_s.length) == 0)
{
if (((current->payload_s.buffer[0] & 0x3) == NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE) || ((current->payload_s.buffer[0] & 0x3) == NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATING))
{
#define _net_nfc_util_free_mem(mem) __net_nfc_util_free_mem((void **)&mem, basename(__FILE__), __LINE__)
bool net_nfc_util_alloc_data(data_s *data, uint32_t length);
-bool net_nfc_util_duplicate_data(data_s *dest, net_nfc_data_s *src);
void net_nfc_util_free_data(data_s *data);
net_nfc_conn_handover_carrier_state_e net_nfc_util_get_cps(net_nfc_conn_handover_carrier_type_e carrier_type);
return 0;
/* Type length is present only for following TNF
- NET_NFC_TNF_NFCWELLKNOWN
- NET_NFC_TNF_MEDIATYPE
- SLP_FRINET_NFC_NDEFRECORD_TNF_ABSURI
- SLP_FRINET_NFC_NDEFRECORD_TNF_NFCEXT
- */
+ NET_NFC_TNF_NFCWELLKNOWN
+ NET_NFC_TNF_MEDIATYPE
+ SLP_FRINET_NFC_NDEFRECORD_TNF_ABSURI
+ SLP_FRINET_NFC_NDEFRECORD_TNF_NFCEXT
+ */
/* ++ is for the Type Length Byte */
RecordLength++;
}
void _net_nfc_handover_bss_on_wifi_activated(wifi_error_e errorCode,
- void* user_data)
+ void* user_data)
{
net_nfc_handover_bss_process_context_t *context = user_data;
if(context == NULL)
g_idle_add(_net_nfc_handover_bss_process_carrier_record,context);
}
-static gboolean _net_nfc_handover_bss_process_carrier_record(gpointer user_data)
+static gboolean _net_nfc_handover_bss_process_carrier_record(
+ gpointer user_data)
{
NFC_DBG("[%s:%d] START", __func__, __LINE__);
_net_nfc_util_free_mem(enc_type.buffer);
}
-/*TO DO : This is a work around,to be replaced by WIFI-DIRECT API*/
+ /*TO DO : This is a work around,to be replaced by WIFI-DIRECT API*/
#if 0
pw_length = wifi_direct_get_passphrase(&passphrase);
NFC_DBG("wifi_direct_get_passphrase[%s]", passphrase);
#ifdef TARGET
static void _net_nfc_wifi_process_error(
- int error,
- net_nfc_handover_bss_get_context_t *context)
+ int error,
+ net_nfc_handover_bss_get_context_t *context)
{
NFC_ERR("_net_nfc_wifi_process_error - [%d]",error);
{
GDBusConnection *connection;
char *id;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
net_nfc_llcp_socket_t socket;
void *user_data;
}
data->invocation);
client_data->id = g_strdup(
g_dbus_method_invocation_get_sender(data->invocation));
- client_data->handle = (net_nfc_target_handle_h)data->handle;
+ client_data->handle = (net_nfc_target_handle_s*)data->handle;
if (net_nfc_controller_llcp_create_socket(&socket,
data->type,
data->invocation);
client_data->id = g_strdup(
g_dbus_method_invocation_get_sender(data->invocation));
- client_data->handle = (net_nfc_target_handle_h)data->handle;
+ client_data->handle = (net_nfc_target_handle_s*)data->handle;
client_data->socket = data->client_socket;
if (net_nfc_controller_llcp_accept(data->client_socket, &result,
data->invocation);
client_data->id = g_strdup(
g_dbus_method_invocation_get_sender(data->invocation));
- client_data->handle = (net_nfc_target_handle_h)data->handle;
+ client_data->handle = (net_nfc_target_handle_s*)data->handle;
if (net_nfc_controller_llcp_create_socket(&socket,
data->type,
data->invocation);
client_data->id = g_strdup(
g_dbus_method_invocation_get_sender(data->invocation));
- client_data->handle = (net_nfc_target_handle_h)data->handle;
+ client_data->handle = (net_nfc_target_handle_s*)data->handle;
if (net_nfc_controller_llcp_create_socket(&socket,
data->type,
}
}
-void net_nfc_server_p2p_discovered(net_nfc_target_handle_h handle)
+void net_nfc_server_p2p_discovered(net_nfc_target_handle_s *handle)
{
NFC_INFO("====== p2p target discovered ======");
GPOINTER_TO_UINT(handle));
}
-void net_nfc_server_p2p_received(data_h user_data)
+void net_nfc_server_p2p_received(data_s *user_data)
{
GVariant *arg_data;
/* server side */
void net_nfc_server_p2p_detached(void);
-void net_nfc_server_p2p_discovered(net_nfc_target_handle_h handle);
+void net_nfc_server_p2p_discovered(net_nfc_target_handle_s *handle);
-void net_nfc_server_p2p_received(data_h user_data);
+void net_nfc_server_p2p_received(data_s *user_data);
void net_nfc_server_p2p_data_sent(net_nfc_error_e result, gpointer user_data);
}
net_nfc_handover_context_t;
-#define NET_NFC_CH_CONTEXT net_nfc_target_handle_s *handle;\
+#define NET_NFC_CH_CONTEXT \
+ net_nfc_target_handle_s *handle;\
net_nfc_llcp_socket_t socket;\
net_nfc_error_e result;\
int step;\
typedef struct _net_nfc_server_handover_create_config_context_t
{
- NET_NFC_CH_CONTEXT;
+ net_nfc_target_handle_s *handle;
+ net_nfc_llcp_socket_t socket;
+ net_nfc_error_e result;
+ int step;
+ net_nfc_conn_handover_carrier_type_e type;
+ void *user_param;
+ // TODO: above value MUST be same with NET_NFC_CH_CONTEXT
_net_nfc_server_handover_create_carrier_msg_cb cb;
net_nfc_conn_handover_carrier_type_e current_type;
typedef struct _net_nfc_server_handover_process_config_context_t
{
- NET_NFC_CH_CONTEXT;
+ net_nfc_target_handle_s *handle;
+ net_nfc_llcp_socket_t socket;
+ net_nfc_error_e result;
+ int step;
+ net_nfc_conn_handover_carrier_type_e type;
+ void *user_param;
+ // TODO: above value MUST be same with NET_NFC_CH_CONTEXT */
net_nfc_server_handover_process_carrier_record_cb cb;
}net_nfc_server_handover_process_config_context_t;
-
static void _net_nfc_server_handover_send_response(net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e carrier,
data_s *ac_data,
/* don't free context */
}
+
static void _net_nfc_server_handover_bt_process_carrier_record_cb(
net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e type,
{
if (context->type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
- if (context->current_type <
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
+ if (context->current_type < NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
context->current_type++;
}
}
else
{
- context->current_type =
- NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
+ context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
}
g_idle_add(
context->type = type;
if (type == NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN)
{
- context->current_type =
- NET_NFC_CONN_HANDOVER_CARRIER_BT;
+ context->current_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
}
else
context->current_type = context->type;
}
static void _net_nfc_server_handover_create_carrier_configs_2_cb(
- net_nfc_error_e result,
- ndef_message_s *selector,
- void *user_param)
+ net_nfc_error_e result, ndef_message_s *selector, void *user_param)
{
- net_nfc_handover_context_t *context =
- (net_nfc_handover_context_t *)user_param;
+ net_nfc_handover_context_t *context = user_param;
NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb result [%d]",
- result);
+ result);
if (context == NULL)
{
(net_nfc_handover_context_t *)user_param;
NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
- result);
+ result);
context->result = result;
if (result == NET_NFC_OK)
NFC_DBG("NET_NFC_LLCP_STEP_04");
/* response select message */
+ // TODO: context->handle may is not valid type. we should find a right function or parameter
result = net_nfc_server_snep_server_send_get_response(
(net_nfc_snep_handle_h)context->handle,
&context->data);
}
/* TODO : send select response to requester */
- result = _net_nfc_server_handover_create_requester_from_rawdata(
- &request,
- data);
+ result = _net_nfc_server_handover_create_requester_from_rawdata(&request, data);
if (result == NET_NFC_OK)
{
(net_nfc_handover_context_t *)user_param;
NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb result [%d]",
- result);
+ result);
context->result = result;
(net_nfc_handover_context_t *)user_param;
NFC_DBG("_net_nfc_server_handover_server_create_carrier_config_cb,result [%d]",
- result);
+ result);
if (context == NULL)
{
ndef_message_s *request;
NFC_DBG("_net_nfc_server_handover_server_recv_cb, socket [%x], result [%d]",
- socket, result);
+ socket, result);
context->result = result;
(net_nfc_handover_context_t *)user_param;
NFC_DBG("_net_nfc_server_handover_server_send_cb socket[%x], result[%d]",
- socket, result);
+ socket, result);
context->result = result;
/* start default handover server using snep */
result =
net_nfc_server_snep_default_server_register_get_response_cb(
- _net_nfc_server_handover_get_response_cb,
- NULL);
+ _net_nfc_server_handover_get_response_cb, NULL);
/* start default handover server */
result = net_nfc_server_llcp_simple_server(
(net_nfc_handover_context_t *)user_param;
NFC_DBG("_net_nfc_server_handover_server_process_carrier_record_cb, result[%d]",
- result);
+ result);
context->result = result;
}
net_nfc_server_cb_data_t;
-typedef struct _net_nfc_server_snep_context_t
-{
- net_nfc_target_handle_s *handle;
- net_nfc_error_e result;
- net_nfc_llcp_socket_t socket;
- uint32_t state;
- uint32_t type;
- data_s data;
- net_nfc_server_snep_cb cb;
- void *user_param;
- GQueue queue;
-}
-net_nfc_server_snep_context_t;
-
typedef struct _net_nfc_server_snep_job_t
{
net_nfc_server_snep_context_t *context;
data_s data;
net_nfc_server_snep_cb cb;
void *user_param;
-}
-net_nfc_server_snep_job_t;
-
+}net_nfc_server_snep_job_t;
typedef struct __net_nfc_server_snep_server_context_t
{
net_nfc_target_handle_s *handle;
int client;
void *user_param;
-}
-_net_nfc_server_snep_server_context_t;
+}_net_nfc_server_snep_server_context_t;
typedef struct __net_nfc_server_snep_service_context_t
{
uint32_t type;
data_s data;
void *user_param;
-}
-_net_nfc_server_snep_service_context_t;
+}_net_nfc_server_snep_service_context_t;
typedef void (*_net_nfc_server_snep_operation_cb)(
net_nfc_error_e result,
}
net_nfc_error_e net_nfc_server_snep_server_send_get_response(
- net_nfc_snep_handle_h snep_handle, data_s *data)
+ net_nfc_server_snep_context_t *snep_handle, data_s *data)
{
- net_nfc_server_snep_context_t *context =
- (net_nfc_server_snep_context_t *)snep_handle;
net_nfc_error_e result = NET_NFC_OK;
- if (context == NULL/* && check valid handle */)
+ if (snep_handle == NULL/* && check valid handle */)
{
NFC_ERR("invalid handle");
return NET_NFC_INVALID_PARAM;
}
- if (net_nfc_server_target_connected(context->handle) == false) {
+ if (net_nfc_server_target_connected(snep_handle->handle) == false) {
return NET_NFC_NOT_CONNECTED;
}
- NFC_DBG("send get response, socket [%x]", context->socket);
+ NFC_DBG("send get response, socket [%x]", snep_handle->socket);
/* check correct status */
- if (context->type == SNEP_REQ_GET)
+ if (snep_handle->type == SNEP_REQ_GET)
{
- if (context->data.buffer != NULL)
- net_nfc_util_free_data(&context->data);
+ if (snep_handle->data.buffer != NULL)
+ net_nfc_util_free_data(&snep_handle->data);
if (data != NULL)
{
- context->type = SNEP_RESP_SUCCESS;
+ snep_handle->type = SNEP_RESP_SUCCESS;
- if (net_nfc_util_alloc_data(&context->data, data->length) == true)
+ if (net_nfc_util_alloc_data(&snep_handle->data, data->length) == true)
{
- memcpy(context->data.buffer, data->buffer,
+ memcpy(snep_handle->data.buffer, data->buffer,
data->length);
}
else
else
{
/* not found */
- context->type = SNEP_RESP_NOT_FOUND;
+ snep_handle->type = SNEP_RESP_NOT_FOUND;
}
- _net_nfc_server_snep_server_process(context);
+ _net_nfc_server_snep_server_process(snep_handle);
}
else
{
}
-net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep,
- uint8_t type, data_s *data, net_nfc_server_snep_cb cb, void *user_param)
+net_nfc_error_e net_nfc_server_snep_client_request(
+ net_nfc_server_snep_context_t *snep,
+ uint8_t type,
+ data_s *data,
+ net_nfc_server_snep_cb cb,
+ void *user_param)
{
- net_nfc_server_snep_context_t *context = (net_nfc_server_snep_context_t *)snep;
net_nfc_error_e result = NET_NFC_OK;
net_nfc_server_snep_job_t *job;
- if (context == NULL || data == NULL || data->buffer == NULL)
+ if (snep == NULL || data == NULL || data->buffer == NULL)
{
return NET_NFC_NULL_PARAMETER;
}
- if (net_nfc_server_target_connected(context->handle) == false) {
+ if (net_nfc_server_target_connected(snep->handle) == false) {
return NET_NFC_NOT_CONNECTED;
}
job->cb = cb;
job->user_param = user_param;
- job->context = context;
- job->handle = context->handle;
- job->socket = context->socket;
+ job->context = snep;
+ job->handle = snep->handle;
+ job->socket = snep->socket;
- g_queue_push_tail(&context->queue, job);
+ g_queue_push_tail(&snep->queue, job);
}
else
{
return NET_NFC_ALLOC_FAIL;
}
- NFC_INFO("enqueued jobs [%d]", g_queue_get_length(&context->queue));
+ NFC_INFO("enqueued jobs [%d]", g_queue_get_length(&snep->queue));
/* if client is idle, starts sending request */
- if (context->state == NET_NFC_LLCP_IDLE)
+ if (snep->state == NET_NFC_LLCP_IDLE)
{
- _net_nfc_server_snep_client_do_job(context);
+ _net_nfc_server_snep_client_do_job(snep);
} else {
NFC_INFO("client is working. this job will be enqueued");
}
}
net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(
- net_nfc_snep_handle_h snep_handle, data_s *data)
+ net_nfc_server_snep_context_t *snep, data_s *data)
{
- net_nfc_server_snep_context_t *context =
- (net_nfc_server_snep_context_t *)snep_handle;
net_nfc_error_e result = NET_NFC_OK;
- if (context == NULL/* && check valid handle */)
+ if (snep == NULL/* && check valid handle */)
{
NFC_ERR("invalid handle");
return NET_NFC_INVALID_PARAM;
}
/* check correct status */
- if (context->type == SNEP_REQ_GET &&
- context->state == NET_NFC_LLCP_STEP_03)
+ if (snep->type == SNEP_REQ_GET &&
+ snep->state == NET_NFC_LLCP_STEP_03)
{
- net_nfc_server_snep_server_send_get_response(snep_handle, data);
+ net_nfc_server_snep_server_send_get_response(snep, data);
}
else
{
SNEP_RESP_REJECT = 0xFF,
} snep_command_field_e;
+typedef struct _net_nfc_server_snep_context_t net_nfc_server_snep_context_t;
+
typedef bool (*net_nfc_server_snep_listen_cb)(net_nfc_snep_handle_h handle,
uint32_t type,
uint32_t max_len,
data_s *data,
void *user_param);
+struct _net_nfc_server_snep_context_t
+{
+ net_nfc_target_handle_s *handle;
+ net_nfc_error_e result;
+ net_nfc_llcp_socket_t socket;
+ uint32_t state;
+ uint32_t type;
+ data_s data;
+ net_nfc_server_snep_cb cb;
+ void *user_param;
+ GQueue queue;
+};
+
net_nfc_error_e net_nfc_server_snep_server( net_nfc_target_handle_s *handle,
const char *san, sap_t sap, net_nfc_server_snep_cb cb, void *user_param);
const char *san, sap_t sap, net_nfc_server_snep_cb cb, void *user_param);
net_nfc_error_e net_nfc_server_snep_server_send_get_response(
- net_nfc_snep_handle_h snep_handle, data_s *data);
+ net_nfc_server_snep_context_t *snep_handle, data_s *data);
-net_nfc_error_e net_nfc_server_snep_client_request(net_nfc_snep_handle_h snep,
- uint8_t type, data_s *data, net_nfc_server_snep_cb cb, void *user_param);
+net_nfc_error_e net_nfc_server_snep_client_request(
+ net_nfc_server_snep_context_t *snep,
+ uint8_t type,
+ data_s *data,
+ net_nfc_server_snep_cb cb,
+ void *user_param);
net_nfc_error_e net_nfc_server_snep_default_server_start(
net_nfc_target_handle_s *handle);
net_nfc_server_snep_listen_cb cb);
net_nfc_error_e net_nfc_server_snep_default_server_send_get_response(
- net_nfc_snep_handle_h snep_handle, data_s *data);
+ net_nfc_server_snep_context_t *snep, data_s *data);
net_nfc_error_e net_nfc_server_snep_default_server_register();
{
NetNfcGDbusSnep *object;
GDBusMethodInvocation *invocation;
- net_nfc_snep_handle_h arg_snep_handle;
+ net_nfc_server_snep_context_t *arg_snep_handle;
net_nfc_snep_type_t arg_type;
GVariant *arg_ndef_msg;
data_s data = { NULL, };
g_assert(invocation != NULL);
/* TODO :
- g_dbus_method_invocation_return_dbus_error(
- invocation,
- "org.tizen.NetNfcService.Snep.DataError",
- "Cannot stop SNEP service");
- */
+ g_dbus_method_invocation_return_dbus_error(
+ invocation,
+ "org.tizen.NetNfcService.Snep.DataError",
+ "Cannot stop SNEP service");
+ */
net_nfc_gdbus_snep_complete_stop_snep(object,
invocation,
static void transceive_data_thread_func(gpointer user_data)
{
- TransceiveSendData *transceive_data = (TransceiveSendData*)user_data;
+ TransceiveSendData *transceive_data = user_data;
net_nfc_target_handle_s *handle =
(net_nfc_target_handle_s *)transceive_data->transceive_handle;
net_nfc_error_e result = NET_NFC_OK;
static void transceive_thread_func(gpointer user_data)
{
- TransceiveSendData *transceive_data = (TransceiveSendData *)user_data;
+ TransceiveSendData *transceive_data = user_data;
net_nfc_target_handle_s *handle =
(net_nfc_target_handle_s *)transceive_data->transceive_handle;
net_nfc_error_e result = NET_NFC_OK;
}
/* check state of launch popup */
- if(net_nfc_app_util_check_launch_state() == TRUE)
+ if(net_nfc_app_util_check_launch_state() == NET_NFC_NO_LAUNCH_APP_SELECT)
{
NFC_DBG("skip launch popup!!!");
result = NET_NFC_OK;
static void p2p_connection_handover_cb(net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e type,
- data_h data,
+ data_s *data,
void *user_data);
-static net_nfc_connection_handover_info_h global_info = NULL;
+static net_nfc_connection_handover_info_s *global_info = NULL;
static void run_next_callback(gpointer user_data)
static void p2p_connection_handover_cb(net_nfc_error_e result,
net_nfc_conn_handover_carrier_type_e type,
- data_h data,
+ data_s *data,
void *user_data)
{
g_print("Connection handover completed\n");
net_nfc_conn_handover_carrier_type_e type, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = net_nfc_test_device_get_target_handle();
g_print("handle for handover : %p \n", handle);
result = net_nfc_client_p2p_connection_handover(
- handle,
- type,
- p2p_connection_handover_cb,
- user_data);
+ handle,
+ type,
+ p2p_connection_handover_cb,
+ user_data);
g_print("net_nfc_client_p2p_connection_handover() : %d\n", result);
}
{
net_nfc_error_e result = NET_NFC_OK;
net_nfc_conn_handover_carrier_type_e out_carrier;
- data_h out_data = NULL;
- net_nfc_target_handle_h handle = NULL;
+ data_s *out_data = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = net_nfc_test_device_get_target_handle();
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- data_h out_data = NULL;
- net_nfc_connection_handover_info_h hand_info = NULL;
+ data_s *out_data = NULL;
+ net_nfc_connection_handover_info_s *hand_info = NULL;
result = net_nfc_client_handover_get_alternative_carrier_data(global_info, &out_data);
g_print(" Get alternative carrier data %d", result);
#include "net_nfc_test_tag.h"
-static net_nfc_target_handle_h get_handle();
-static void run_next_callback(gpointer user_data);
-static void jewel_read_cb(net_nfc_error_e result, data_h resp_data, void *user_data);
-static void jewel_write_cb(net_nfc_error_e result, void* user_data);
-
-static net_nfc_target_handle_h get_handle()
+static net_nfc_target_handle_s* get_handle()
{
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
/*********************************** Callbacks *************************************/
static void jewel_read_cb(net_nfc_error_e result,
- data_h resp_data,
+ data_s *resp_data,
void *user_data)
{
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = get_handle();
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block = 0x01;
uint8_t byte = 1;
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = get_handle();
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block = 0x01;
uint8_t byte = 1;
uint8_t data_to_write = 'A';
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block = 0x01;
uint8_t byte = 1;
uint8_t data_to_write = 'A';
void net_nfc_test_tag_jewel_read_id(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_jewel_read_byte(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_jewel_read_all(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_jewel_write_with_erase(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_jewel_write_with_no_erase(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif //__NET_NFC_TEST_JEWEL_TAG_H__
\ No newline at end of file
static net_nfc_llcp_socket_t server_test_socket;
static net_nfc_llcp_socket_t client_test_socket;
-static net_nfc_llcp_config_info_h llcp_config = NULL;
-static net_nfc_llcp_config_info_h llcp_config_sync = NULL;
-static net_nfc_llcp_config_info_h llcp_config_default = NULL;
-static net_nfc_llcp_config_info_h llcp_config_default_sync = NULL;
+static net_nfc_llcp_config_info_s *llcp_config = NULL;
+static net_nfc_llcp_config_info_s *llcp_config_sync = NULL;
+static net_nfc_llcp_config_info_s *llcp_config_default = NULL;
+static net_nfc_llcp_config_info_s *llcp_config_default_sync = NULL;
/*********************************** utility Calls *************************************/
-static void run_next_callback(gpointer user_data);
-
static void run_next_callback(gpointer user_data)
{
if (user_data)
/*********************************** Callbacks *************************************/
-static void llcp_default_config_cb(net_nfc_error_e result,
- void *user_data)
+static void llcp_default_config_cb(net_nfc_error_e result, void *user_data)
{
g_print(" llcp_default_config_cb Completed %d\n", result);
run_next_callback(user_data);
}
-static void llcp_custom_config_cb(net_nfc_error_e result,
- void *user_data)
+static void llcp_custom_config_cb(net_nfc_error_e result, void *user_data)
{
g_print("llcp_custom_config_cb Completed %d\n", result);
}
static void llcp_listen_socket_cb(net_nfc_error_e result,
- net_nfc_llcp_socket_t client_socket,
- void *user_data)
+ net_nfc_llcp_socket_t client_socket, void *user_data)
{
g_print("llcp_listen_socket_cb Completed %d\n", client_socket);
run_next_callback(user_data);
}
-static void llcp_receive_socket_cb(net_nfc_error_e result,
- data_h data,
+static void llcp_receive_socket_cb(net_nfc_error_e result, data_s *data,
void *user_data)
{
- data_h received_data = data;
+ data_s *received_data = data;
print_received_data(received_data);
static void llcp_receive_from_socket_cb(net_nfc_error_e result,
sap_t sap,
- data_h data,
+ data_s *data,
void *user_data)
{
- data_h received_data = data;
+ data_s *received_data = data;
print_received_data(received_data);
static void llcp_connect_socket_cb(net_nfc_error_e result,
- net_nfc_llcp_socket_t client_socket,
- void *user_data)
+ net_nfc_llcp_socket_t client_socket, void *user_data)
{
g_print("llcp_connect_socket_cb Completed %d\n", client_socket);
g_print("llcp_connect_socket_cb Completed %d\n", result);
}
-static void llcp_send_socket_cb(net_nfc_error_e result,
- void *user_data)
+static void llcp_send_socket_cb(net_nfc_error_e result, void *user_data)
{
g_print("llcp_send_socket_cb Completed %d\n", result);
run_next_callback(user_data);
-
}
-static void llcp_send_to_socket_cb(net_nfc_error_e result,
- void *user_data)
+static void llcp_send_to_socket_cb(net_nfc_error_e result, void *user_data)
{
g_print("llcp_send_to_socket_cb Completed %d\n", result);
run_next_callback(user_data);
-
}
-static void llcp_disconnect_socket_cb(net_nfc_error_e result,
- void *user_data)
+static void llcp_disconnect_socket_cb(net_nfc_error_e result, void *user_data)
{
g_print("llcp_send_to_socket_cb Completed %d\n", result);
run_next_callback(user_data);
-
}
-
/*********************************** Function Calls *************************************/
-void net_nfc_test_llcp_default_config(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_default_config(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
}
-void net_nfc_test_llcp_default_config_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_default_config_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
g_print(" llcp create default config failed: %d\n", result);
run_next_callback(user_data);
return;
-
}
result = net_nfc_client_llcp_config_sync(llcp_config_default_sync);
{
g_print(" llcp create default config (sync) success: %d\n", result);
}
-
}
-void net_nfc_test_llcp_custom_config(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_custom_config(gpointer data, gpointer user_data)
{
-
net_nfc_error_e result;
result = net_nfc_client_llcp_create_config(&llcp_config,128, 1, 10, 0);
g_print(" llcp create custom config failed: %d\n", result);
run_next_callback(user_data);
return;
-
}
- result = net_nfc_client_llcp_config(llcp_config,
- llcp_custom_config_cb,
- user_data);
-
+ result = net_nfc_client_llcp_config(llcp_config, llcp_custom_config_cb, user_data);
}
-void net_nfc_test_llcp_custom_config_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_custom_config_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
g_print(" net_nfc_test_llcp_custom_config_sync failed: %d\n", result);
run_next_callback(user_data);
return;
-
}
result = net_nfc_client_llcp_config_sync(llcp_config_sync);
}
-void net_nfc_test_llcp_get_local_config(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_get_local_config(gpointer data, gpointer user_data)
{
- net_nfc_llcp_config_info_h local_config;
+ net_nfc_llcp_config_info_s *local_config;
net_nfc_error_e result;
result = net_nfc_client_llcp_get_local_config(&local_config);
g_print(" llcp create custom config failed: %d\n", result);
run_next_callback(user_data);
return;
-
}
g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->miu);
g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->wks);
g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->lto);
g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option);
-
}
/*commented because remote config API is not available*/
-/*
- void net_nfc_test_llcp_get_remote_config(gpointer data,
- gpointer user_data)
- {
- net_nfc_llcp_config_info_h local_config;
- net_nfc_error_e result;
+#if 0
+void net_nfc_test_llcp_get_remote_config(gpointer data,
+ gpointer user_data)
+{
+ net_nfc_llcp_config_info_s *local_config;
+ net_nfc_error_e result;
- result = net_nfc_client_llcp_get_local_config(&local_config);
+ result = net_nfc_client_llcp_get_local_config(&local_config);
- if(result != NET_NFC_OK)
- {
- g_print(" llcp create custom config failed: %d\n", result);
- run_next_callback(user_data);
- return;
+ if(result != NET_NFC_OK)
+ {
+ g_print(" llcp create custom config failed: %d\n", result);
+ run_next_callback(user_data);
+ return;
- }
+ }
- g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->miu);
- g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->wks);
- g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->lto);
- g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option);
+ g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->miu);
+ g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->wks);
+ g_print(" net_nfc_test_llcp_get_local_config: %d\n", local_config->lto);
+ g_print("net_nfc_test_llcp_get_local_config: %d\n", local_config->option);
- }
- */
+}
+#endif
void net_nfc_test_llcp_get_config_miu(gpointer data,
gpointer user_data)
void net_nfc_test_llcp_create_custom_socket_option(gpointer data,
gpointer user_data)
{
- net_nfc_llcp_socket_option_h option;
+ net_nfc_llcp_socket_option_s *option;
net_nfc_error_e result;
result = net_nfc_client_llcp_create_socket_option(&option,
void net_nfc_test_llcp_create_default_socket_option(gpointer data,
gpointer user_data)
{
- net_nfc_llcp_socket_option_h option;
+ net_nfc_llcp_socket_option_s *option;
net_nfc_error_e result;
result = net_nfc_client_llcp_create_socket_option_default(&option);
gpointer user_data)
{
net_nfc_error_e result;
- net_nfc_llcp_socket_option_h option;
+ net_nfc_llcp_socket_option_s *option;
result = net_nfc_client_llcp_get_local_socket_option(client_test_socket,&option);
gpointer user_data)
{
net_nfc_error_e result;
- data_h out_data;
+ data_s *out_data;
result = net_nfc_client_llcp_receive_sync(server_test_socket,
}
}
-void net_nfc_test_llcp_receive_from_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_receive_from_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
- data_h out_data = NULL;
+ data_s *out_data = NULL;
sap_t sap_data = 0;
result = net_nfc_client_llcp_receive_from_sync(server_test_socket,
run_next_callback(user_data);
}
-
-
-void net_nfc_test_llcp_connect(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_connect(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
}
-void net_nfc_test_llcp_connect_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_connect_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
net_nfc_llcp_socket_t out_socket;
run_next_callback(user_data);
}
-void net_nfc_test_llcp_connect_sap(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_connect_sap(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
}
-void net_nfc_test_llcp_connect_sap_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_llcp_connect_sap_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
net_nfc_llcp_socket_t out_socket;
net_nfc_client_llcp_create_socket(&client_test_socket, NULL);
- result = net_nfc_client_llcp_connect_sap_sync(client_test_socket,
- 16,
- &out_socket);
+ result = net_nfc_client_llcp_connect_sap_sync(client_test_socket, 16, &out_socket);
if(result != NET_NFC_OK)
{
run_next_callback(user_data);
}
-
-
-void net_nfc_test_llcp_send(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_send(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
}
-void net_nfc_test_llcp_send_sync(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_send_sync(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
- result = net_nfc_client_llcp_send_sync(client_test_socket,
- data);
+ result = net_nfc_client_llcp_send_sync(client_test_socket, data);
if(result != NET_NFC_OK)
{
}
-void net_nfc_test_llcp_send_to(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_send_to(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
}
-void net_nfc_test_llcp_send_to_sync(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_send_to_sync(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
}
-void net_nfc_test_llcp_disconnect(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_disconnect(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
}
-void net_nfc_test_llcp_disconnect_server(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_disconnect_server(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
}
}
-
-void net_nfc_test_llcp_disconnect_sync(gpointer func_data,
- gpointer user_data)
+void net_nfc_test_llcp_disconnect_sync(gpointer func_data, gpointer user_data)
{
net_nfc_error_e result;
void net_nfc_test_llcp_set_config_option(gpointer data, gpointer user_data);
void net_nfc_test_llcp_free_config(gpointer data, gpointer user_data);
void net_nfc_test_llcp_create_custom_socket_option(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_llcp_create_default_socket_option(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_llcp_get_local_socket_option(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_llcp_get_socket_option_miu(gpointer data, gpointer user_data);
void net_nfc_test_llcp_set_socket_option_miu(gpointer data, gpointer user_data);
void net_nfc_test_llcp_get_socket_option_rw(gpointer data, gpointer user_data);
void net_nfc_test_llcp_set_socket_option_rw(gpointer data, gpointer user_data);
void net_nfc_test_llcp_get_socket_option_type(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_llcp_set_socket_option_type(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_llcp_free_socket_option(gpointer data, gpointer user_data);
void net_nfc_test_llcp_listen(gpointer data, gpointer user_data);
void net_nfc_test_llcp_listen_sync(gpointer data, gpointer user_data);
#include "net_nfc_client_manager.h"
#include "net_nfc_typedef_internal.h"
-static void run_next_callback(gpointer user_data);
-
-static void print_server_state(gint state);
-
-static void set_activated_cb(bool state,
- void *user_data);
-
-static void set_active_completed_cb(net_nfc_error_e result,
- void *user_data);
-
-static void get_server_state_completed_cb(net_nfc_error_e result,
- unsigned int state,
- void *user_data);
static void run_next_callback(gpointer user_data)
{
g_print("Activated state %d\n", state);
}
-static void set_active_completed_cb(net_nfc_error_e result,
- void *user_data)
+static void set_active_completed_cb(net_nfc_error_e result, void *user_data)
{
g_print("SetActive Completed %d\n", result);
run_next_callback(user_data);
run_next_callback(user_data);
}
-void net_nfc_test_manager_set_active(gpointer data,
- gpointer user_data)
+void net_nfc_test_manager_set_active(gpointer data, gpointer user_data)
{
net_nfc_client_manager_set_activated(set_activated_cb, NULL);
user_data);
}
-void net_nfc_test_manager_get_server_state(gpointer data,
- gpointer user_data)
+void net_nfc_test_manager_get_server_state(gpointer data, gpointer user_data)
{
net_nfc_client_manager_get_server_state(get_server_state_completed_cb,
user_data);
}
-void net_nfc_test_manager_set_active_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_manager_set_active_sync(gpointer data, gpointer user_data)
{
gint i;
#include "net_nfc_ndef_record.h"
#include "net_nfc_test_util.h"
-
-static void run_next_callback(gpointer user_data);
-
-static void print_record_well_known_type(ndef_record_h record);
-
-static void print_record(ndef_record_h record);
-
-static void print_ndef_message(ndef_message_h message);
-
-static net_nfc_target_handle_h ndef_get_handle(void);
-
-static ndef_message_h create_ndef_message_text(const gchar *str,
- const gchar *lang,
- net_nfc_encode_type_e encode);
-
-static void set_string(const gchar *str);
-
-static gchar *get_write_string(void);
-
-
-static void ndef_read_cb(net_nfc_error_e result,
- ndef_message_h message,
- void *user_data);
-
-static void ndef_write_cb(net_nfc_error_e result,
- void *user_data);
-
-static void ndef_make_read_only_cb(net_nfc_error_e result,
- void *user_data);
-
-static void ndef_format_cb(net_nfc_error_e result,
- void *user_data);
-
static gchar *ndef_str = NULL;
static gint ndef_count = 0;
}
}
-static void print_record_well_known_type(ndef_record_h record)
+static void set_string(const gchar *str)
+{
+ gint count = 0;
+
+ if (str == NULL)
+ return;
+
+ sscanf(str, "Count: %d", &count);
+
+ if (count == 0)
+ ndef_str = g_strdup(str);
+ else
+ {
+ gchar *tmp;
+ gchar *pos;
+
+ pos = (gchar *)str;
+ tmp = g_strdup_printf("Count: %d", count);
+ if (strncmp(pos, tmp, strlen(tmp)) == 0)
+ {
+ if (*pos == ' ')
+ pos++;
+
+ ndef_str = g_strdup(pos + strlen(tmp));
+ }
+
+ g_free(tmp);
+ }
+
+ ndef_count = count;
+}
+
+static void print_record_well_known_type(ndef_record_s *record)
{
gchar *uri = NULL;
gchar *lang = NULL;
}
}
-static void print_record(ndef_record_h record)
+static void print_record(ndef_record_s *record)
{
guint8 flag;
gchar *str = NULL;
net_nfc_record_tnf_e tnf;
- data_h type = NULL;
- data_h id = NULL;
- data_h payload = NULL;
+ data_s *type = NULL;
+ data_s *id = NULL;
+ data_s *payload = NULL;
net_nfc_get_record_flags(record, &flag);
net_nfc_get_record_tnf(record, &tnf);
}
}
-static void print_ndef_message(ndef_message_h message)
+static void print_ndef_message(ndef_message_s *message)
{
gint count = 0;
gint i;
for (i = 0; i < count; i++)
{
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
g_print("Record count : %d\n", i+1);
- if (net_nfc_get_record_by_index(message,
- i,
- &record) != NET_NFC_OK)
+ if (net_nfc_get_record_by_index(message, i, &record) != NET_NFC_OK)
{
g_print("can not get record from index %d\n", i);
continue;
g_print("\n");
}
-static net_nfc_target_handle_h ndef_get_handle(void)
+static net_nfc_target_handle_s* ndef_get_handle(void)
{
- net_nfc_target_info_h info;
- net_nfc_target_handle_h handle;
+ net_nfc_target_info_s *info;
+ net_nfc_target_handle_s *handle;
bool is_ndef = false;
info = net_nfc_test_tag_get_target_info();
if (info == NULL)
{
- g_print("net_nfc_target_info_h is NULL\n");
+ g_print("net_nfc_target_info_s *is NULL\n");
return NULL;
}
return handle;
}
-static ndef_message_h create_ndef_message_text(const gchar *str,
+static ndef_message_s *create_ndef_message_text(const gchar *str,
const gchar *lang,
net_nfc_encode_type_e encode)
{
- ndef_record_h record = NULL;
- ndef_message_h message = NULL;
+ ndef_record_s *record = NULL;
+ ndef_message_s *message = NULL;
if (net_nfc_create_ndef_message(&message) != NET_NFC_OK)
{
return message;
}
-static void set_string(const gchar *str)
-{
- gint count = 0;
-
- if (str == NULL)
- return;
-
- sscanf(str, "Count: %d", &count);
-
- if (count == 0)
- ndef_str = g_strdup(str);
- else
- {
- gchar *tmp;
- gchar *pos;
-
- pos = (gchar *)str;
- tmp = g_strdup_printf("Count: %d", count);
- if (strncmp(pos, tmp, strlen(tmp)) == 0)
- {
- if (*pos == ' ')
- pos++;
-
- ndef_str = g_strdup(pos + strlen(tmp));
- }
-
- g_free(tmp);
- }
-
- ndef_count = count;
-}
-
static gchar *get_write_string(void)
{
gchar *str = NULL;
return str;
}
-static void ndef_read_cb(net_nfc_error_e result,
- ndef_message_h message,
+static void ndef_read_cb(net_nfc_error_e result, ndef_message_s *message,
void *user_data)
{
g_print("Read NDEF Completed %d\n", result);
run_next_callback(user_data);
}
-static void ndef_write_cb(net_nfc_error_e result,
- void *user_data)
+static void ndef_write_cb(net_nfc_error_e result, void *user_data)
{
g_print("Write NDEF Completed %d\n", result);
}
-static void ndef_make_read_only_cb(net_nfc_error_e result,
- void *user_data)
+static void ndef_make_read_only_cb(net_nfc_error_e result, void *user_data)
{
g_print("Make Read only Completed %d\n", result);
run_next_callback(user_data);
}
-static void ndef_format_cb(net_nfc_error_e result,
- void *user_data)
+static void ndef_format_cb(net_nfc_error_e result, void *user_data)
{
g_print("NDEF Format Completed: %d\n", result);
-void net_nfc_test_ndef_read(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_read(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
handle = ndef_get_handle();
if (handle == NULL)
g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
- net_nfc_client_ndef_read(handle,
- ndef_read_cb,
- user_data);
+ net_nfc_client_ndef_read(handle, ndef_read_cb, user_data);
}
-void net_nfc_test_ndef_write(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_write(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
- ndef_message_h message;
+ net_nfc_target_handle_s *handle;
+ ndef_message_s *message;
gchar *str = NULL;
return;
}
- message = create_ndef_message_text(str,
- "en-US",
- NET_NFC_ENCODE_UTF_8);
+ message = create_ndef_message_text(str, "en-US", NET_NFC_ENCODE_UTF_8);
g_free(str);
return;
}
- net_nfc_client_ndef_write(handle,
- message,
- ndef_write_cb,
- user_data);
+ net_nfc_client_ndef_write(handle, message, ndef_write_cb, user_data);
}
-void net_nfc_test_ndef_make_read_only(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_make_read_only(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
handle = ndef_get_handle();
if (handle == NULL)
user_data);
}
-void net_nfc_test_ndef_format(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_format(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
- data_h key;
+ net_nfc_target_handle_s *handle;
+ data_s *key;
guint8 format_data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
handle = ndef_get_handle();
net_nfc_create_data(&key, format_data, 6);
- net_nfc_client_ndef_format(handle,
- key,
- ndef_format_cb,
- user_data);
+ net_nfc_client_ndef_format(handle, key, ndef_format_cb, user_data);
net_nfc_free_data(key);
return;
}
-void net_nfc_test_ndef_read_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_read_sync(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
- ndef_message_h message = NULL;
+ net_nfc_target_handle_s *handle;
+ ndef_message_s *message = NULL;
net_nfc_error_e result;
handle = ndef_get_handle();
run_next_callback(user_data);
}
-void net_nfc_test_ndef_write_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_write_sync(gpointer data, gpointer user_data)
{
gchar *str = NULL;
- net_nfc_target_handle_h handle;
- ndef_message_h message;
+ net_nfc_target_handle_s *handle;
+ ndef_message_s *message;
net_nfc_error_e result;
handle = ndef_get_handle();
return;
}
- message = create_ndef_message_text(str,
- "en-US",
- NET_NFC_ENCODE_UTF_8);
+ message = create_ndef_message_text(str, "en-US", NET_NFC_ENCODE_UTF_8);
g_free(str);
run_next_callback(user_data);
}
-void net_nfc_test_ndef_make_read_only_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_make_read_only_sync(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
net_nfc_error_e result;
handle = ndef_get_handle();
run_next_callback(user_data);
}
-void net_nfc_test_ndef_format_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_ndef_format_sync(gpointer data, gpointer user_data)
{
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
net_nfc_error_e result;
- data_h key;
+ data_s *key;
guint8 format_data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
handle = ndef_get_handle();
#include "net_nfc_typedef.h"
-static net_nfc_target_handle_h global_handle = NULL;
+static net_nfc_target_handle_s *global_handle = NULL;
+
static void run_next_callback(gpointer user_data);
static void p2p_send(net_nfc_error_e result, void *user_data);
-static void p2p_device_discovered(net_nfc_target_handle_h handle,
+static void p2p_device_discovered(net_nfc_target_handle_s *handle,
void *user_data);
static void p2p_device_detached(void * user_data);
-static void p2p_device_data_received(data_h p2p_data, void *user_data);
+static void p2p_device_data_received(data_s *p2p_data, void *user_data);
static void run_next_callback(gpointer user_data)
{
run_next_callback(user_data);
}
-static void p2p_device_discovered(net_nfc_target_handle_h handle, void *user_data)
+static void p2p_device_discovered(net_nfc_target_handle_s *handle, void *user_data)
{
g_print("Target is Discovered\n");
global_handle = handle;
run_next_callback(user_data);
}
-static void p2p_device_data_received(data_h p2p_data, void *user_data)
+static void p2p_device_data_received(data_s *p2p_data, void *user_data)
{
g_print("P2P data is received\n");
void net_nfc_test_p2p_send(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
- data_h rawdata = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
+ data_s *rawdata = NULL;
net_nfc_create_ndef_message (&msg);
net_nfc_create_uri_type_record (&record ,"http://www.samsung.com" ,NET_NFC_SCHEMA_FULL_URI);
void net_nfc_test_p2p_send_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
- data_h rawdata = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
+ data_s *rawdata = NULL;
net_nfc_create_ndef_message (&msg);
net_nfc_create_uri_type_record (&record ,"http://www.samsung.com", NET_NFC_SCHEMA_FULL_URI);
net_nfc_client_p2p_set_data_received(p2p_device_data_received, user_data);
}
-net_nfc_target_handle_h net_nfc_test_device_get_target_handle(void)
+net_nfc_target_handle_s *net_nfc_test_device_get_target_handle(void)
{
return global_handle;
}
void net_nfc_test_p2p_unset_device_discovered(gpointer data, gpointer user_data);
void net_nfc_test_p2p_unset_device_detached(gpointer data, gpointer user_data);
void net_nfc_test_p2p_unset_data_received(gpointer data, gpointer user_data);
-net_nfc_target_handle_h net_nfc_test_device_get_target_handle(void);
+net_nfc_target_handle_s* net_nfc_test_device_get_target_handle(void);
#endif //__NET_NFC_TEST_P2P_H__
static void run_next_callback(gpointer user_data);
-static void send_apdu_cb(net_nfc_error_e result, data_h data, void *user_data);
+static void send_apdu_cb(net_nfc_error_e result, data_s *data, void *user_data);
static void set_secure_element_cb(net_nfc_error_e result, void *user_data);
static void open_secure_element_cb(net_nfc_error_e result,
- net_nfc_target_handle_h handle, void *user_data);
+ net_nfc_target_handle_s *handle, void *user_data);
static void close_secure_element_cb(net_nfc_error_e result, void *user_data);
-static void get_atr_secure_element_cb(net_nfc_error_e result, data_h data,
+static void get_atr_secure_element_cb(net_nfc_error_e result, data_s *data,
void *user_data);
static void se_set_event_cb(net_nfc_message_e event, void *user_data);
-static void se_ese_detection_cb(net_nfc_target_handle_h handle, int dev_type,
- data_h data, void *user_data);
+static void se_ese_detection_cb(net_nfc_target_handle_s *handle, int dev_type,
+ data_s *data, void *user_data);
-static void se_set_transaction_cb(data_h aid, data_h param, void *user_data);
+static void se_set_transaction_cb(data_s *aid, data_s *param, void *user_data);
/*This handle would be intialized by open secure element callback function*/
-static net_nfc_target_handle_h global_handle = NULL;
+static net_nfc_target_handle_s *global_handle = NULL;
static void run_next_callback(gpointer user_data)
{
}
}
-static void send_apdu_cb(net_nfc_error_e result, data_h data, void *user_data)
+static void send_apdu_cb(net_nfc_error_e result, data_s *data, void *user_data)
{
g_print(" Send apdu data completed \n");
print_received_data(data);
}
static void open_secure_element_cb(net_nfc_error_e result,
- net_nfc_target_handle_h handle, void* user_data)
+ net_nfc_target_handle_s *handle, void* user_data)
{
g_print("Open secure element completed\n");
// assigning received handle
run_next_callback(user_data);
}
-static void get_atr_secure_element_cb(net_nfc_error_e result, data_h data,
+static void get_atr_secure_element_cb(net_nfc_error_e result, data_s *data,
void* user_data)
{
g_print("get atr completed\n");
run_next_callback(user_data);
}
-static void se_set_event_cb(net_nfc_message_e event, void* user_data)
+static void se_set_event_cb(net_nfc_message_e event, void *user_data)
{
g_print("Event callback set successfully\n");
g_print(" Event received %d", event);
run_next_callback(user_data);
}
-static void se_ese_detection_cb(net_nfc_target_handle_h handle, int dev_type,
- data_h data, void *user_data)
+static void se_ese_detection_cb(net_nfc_target_handle_s *handle, int dev_type,
+ data_s *data, void *user_data)
{
g_print("Set ese detection callback successfully\n");
g_print("Handle is %#x\n", GPOINTER_TO_UINT(handle));
print_received_data(data);
}
-static void se_set_transaction_cb(data_h aid, data_h param, void *user_data)
+static void se_set_transaction_cb(data_s *aid, data_s *param, void *user_data)
{
g_print("Set transaction callback successfully\n");
g_print("*****displaying Aid data****\n");
void net_nfc_test_se_send_apdu(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- data_h apdu_data = NULL;
+ data_s *apdu_data = NULL;
uint8_t apdu_cmd[4] = {0x00, 0xA4, 0x00, 0x0C};
net_nfc_create_data(&apdu_data, apdu_cmd, 4);
void net_nfc_test_se_send_apdu_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- data_h apdu_data = NULL;
+ data_s *apdu_data = NULL;
uint8_t apdu_cmd[4] = {0x00, 0xA4, 0x00, 0x0C};
- data_h response = NULL;
+ data_s *response = NULL;
net_nfc_create_data(&apdu_data, apdu_cmd, 4);
result = net_nfc_client_se_send_apdu_sync(global_handle, apdu_data, &response);
void net_nfc_test_se_get_atr_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- data_h attr_data = NULL;
+ data_s *attr_data = NULL;
result = net_nfc_client_se_get_atr_sync(global_handle, &attr_data);
void net_nfc_test_se_send_apdu(gpointer data,
- gpointer user_data );
+ gpointer user_data );
void net_nfc_test_se_send_apdu_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_set_secure_element_type(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_set_secure_element_type_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_open_internal_secure_element(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_open_internal_secure_element_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_close_internal_secure_element(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_close_internal_secure_element_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_get_atr(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_get_atr_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_set_event_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_unset_event_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_set_ese_detection_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_unset_ese_detection_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_set_transaction_event_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_se_unset_transaction_event_cb(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif
#define TEST_SAN "urn:nfc:sn:testsnep"
#define TEST_SAP 30
-static net_nfc_target_info_h target_info = NULL;
+static net_nfc_target_info_s *target_info = NULL;
static net_nfc_snep_handle_h snep_handle = NULL;
-static net_nfc_target_handle_h target_handle = NULL;
+static net_nfc_target_handle_s *target_handle = NULL;
static void run_next_callback(gpointer user_data);
-static void snep_tag_discovered_cb(net_nfc_target_info_h info,
+static void snep_tag_discovered_cb(net_nfc_target_info_s *info,
void *user_data);
-static void snep_p2p_device_discovered_cb(net_nfc_target_handle_h handle,
+static void snep_p2p_device_discovered_cb(net_nfc_target_handle_s *handle,
void *user_data);
static void snep_tag_detached_cb(void *user_data);
static void snep_start_server_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data);
static void snep_start_client_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data);
static void snep_send_request_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data);
g_print("TagDetached\n");
}
-static void snep_tag_discovered_cb(net_nfc_target_info_h info,
- void *user_data)
+static void snep_tag_discovered_cb(net_nfc_target_info_s *info, void *user_data)
{
g_print("TagDiscovered\n");
run_next_callback(user_data);
}
-static void snep_p2p_device_discovered_cb(net_nfc_target_handle_h handle,
+static void snep_p2p_device_discovered_cb(net_nfc_target_handle_s *handle,
void *user_data)
{
g_print("Target is Discovered\n");
static void snep_start_server_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data)
{
static void snep_start_client_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data)
{
static void snep_send_request_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data)
{
net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data)
{
net_nfc_llcp_state_t state = event;
static void snep_unregister_server_cb(net_nfc_snep_handle_h target,
net_nfc_snep_type_t event,
net_nfc_error_e result,
- ndef_message_h msg,
+ ndef_message_s *msg,
void *user_data)
{
/******************************API Calls*********************************************/
-void net_nfc_test_snep_set_tag_discovered(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_set_tag_discovered(gpointer data, gpointer user_data)
{
g_print("Waiting for TagDiscovered Singal\n");
g_print("Device Discovered\n");
}
-void net_nfc_test_snep_start_server(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_start_server(gpointer data, gpointer user_data)
{
net_nfc_error_e result= NET_NFC_OK;
}
-void net_nfc_test_snep_start_server_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_start_server_sync(gpointer data, gpointer user_data)
{
#if 0
net_nfc_error_e result;
guint out_result;
- ndef_message_h msg=NULL;
+ ndef_message_s *msg=NULL;
result = net_nfc_client_snep_start_server_sync(target_info->handle,
"urn:nfc:xsn:samsung.com:testllcp",
}
-void net_nfc_test_snep_start_client(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_start_client(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
g_print(" net_nfc_test_snep_start_client result: %d\n", result);
}
-
-
-void net_nfc_test_snep_send_client_request(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_send_client_request(gpointer data, gpointer user_data)
{
net_nfc_error_e result= NET_NFC_OK;
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
if( (error = net_nfc_create_uri_type_record(&record,
- "http://www.naver.com",
+ "http://www.samsung.com",
NET_NFC_SCHEMA_FULL_URI)) == NET_NFC_OK)
{
if( (error = net_nfc_create_ndef_message(&msg)) == NET_NFC_OK)
{
- if( (error = net_nfc_append_record_to_ndef_message(
- msg,
- record)) == NET_NFC_OK)
+ if ((error = net_nfc_append_record_to_ndef_message(msg, record)) == NET_NFC_OK)
{
result = net_nfc_client_snep_send_client_request(
target_handle,
}
}
-
-
-void net_nfc_test_snep_register_server(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_register_server(gpointer data, gpointer user_data)
{
net_nfc_error_e result= NET_NFC_OK;
run_next_callback(user_data);
}
-void net_nfc_test_snep_unregister_server(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_unregister_server(gpointer data, gpointer user_data)
{
net_nfc_error_e result= NET_NFC_OK;
}
-
-void net_nfc_test_snep_stop_service_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_snep_stop_service_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result= NET_NFC_OK;
gpointer user_data);
void net_nfc_test_sys_handler_set_launch_popup_state_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_sys_handler_set_launch_popup_state_force(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_sys_handler_set_launch_popup_state_force_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif//__NET_NFC_TEST_SYS_HANDLER_H__
#include "net_nfc_client_tag.h"
#include "net_nfc_test_tag.h"
-static void run_next_callback(gpointer user_data);
-#if 0
-static gchar *tag_type_to_string(net_nfc_target_type_e dev_type);
-#endif
-static void print_is_tag_connected(net_nfc_target_type_e dev_type);
-
-static void print_get_current_tag_info(net_nfc_target_info_h info);
-
-static void print_get_current_target_handle(net_nfc_target_handle_h handle);
-#if 0
-static void is_tag_connected_completed(net_nfc_error_e result,
- net_nfc_target_type_e dev_type,
- void *user_data);
-
-static void get_current_tag_info_completed(net_nfc_error_e result,
- net_nfc_target_info_h info,
- void *user_data);
-
-static void get_current_target_handle_completed(net_nfc_error_e result,
- net_nfc_target_handle_h handle,
- void *user_data);
-#endif
-static void tag_detached(void *user_data);
-
-static void tag_discovered(net_nfc_target_info_h info,
- void *user_data);
-
-static net_nfc_target_info_h global_info = NULL;
-
+static net_nfc_target_info_s *global_info = NULL;
static void run_next_callback(gpointer user_data)
{
}
}
-static void print_get_current_tag_info(net_nfc_target_info_h info)
+static void print_get_current_target_handle(net_nfc_target_handle_s *handle)
+{
+ net_nfc_target_handle_s *global_handle;
+ guint global_handle_id;
+ guint handle_id;
+
+ net_nfc_get_tag_handle(global_info, &global_handle);
+
+ global_handle_id = GPOINTER_TO_UINT(global_handle);
+ handle_id = GPOINTER_TO_UINT(handle);
+
+ g_print("Tag handle %x, Current Tag handle %x\n",
+ global_handle_id,
+ handle_id);
+ if (global_handle_id == handle_id)
+ g_print("Current Tag is matched discovered Tag\n");
+}
+
+static void print_get_current_tag_info(net_nfc_target_info_s *info)
{
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
if (global_info == NULL)
{
return;
}
-static void print_get_current_target_handle(net_nfc_target_handle_h handle)
-{
- net_nfc_target_handle_h global_handle;
- guint global_handle_id;
- guint handle_id;
-
- net_nfc_get_tag_handle(global_info, &global_handle);
-
- global_handle_id = GPOINTER_TO_UINT(global_handle);
- handle_id = GPOINTER_TO_UINT(handle);
-
- g_print("Tag handle %x, Current Tag handle %x\n",
- global_handle_id,
- handle_id);
- if (global_handle_id == handle_id)
- g_print("Current Tag is matched discovered Tag\n");
-}
-
static void tag_detached(void *user_data)
{
g_print("TagDetached\n");
}
static void get_current_tag_info_completed(net_nfc_error_e result,
- net_nfc_target_info_h info,
- void *user_data)
+ net_nfc_target_info_s *info, void *user_data)
{
g_print("GetCurrentTagInfo Completed %d\n", result);
}
static void get_current_target_handle_completed(net_nfc_error_e result,
- net_nfc_target_handle_h handle,
- void *user_data)
+ net_nfc_target_handle_s *handle, void *user_data)
{
g_print("GetCurrentTargetHandle Completed %d\n", result);
}
#endif
-static void tag_discovered(net_nfc_target_info_h info,
- void *user_data)
+
+static void tag_discovered(net_nfc_target_info_s *info, void *user_data)
{
g_print("TagDiscovered\n");
#if 0
-void net_nfc_test_tag_is_tag_connected(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_is_tag_connected(gpointer data, gpointer user_data)
{
net_nfc_client_tag_is_tag_connected(is_tag_connected_completed,
user_data);
}
-void net_nfc_test_tag_get_current_tag_info(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_get_current_tag_info(gpointer data, gpointer user_data)
{
net_nfc_client_tag_get_current_tag_info(get_current_tag_info_completed,
user_data);
user_data);
}
#endif
-void net_nfc_test_tag_is_tag_connected_sync(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_is_tag_connected_sync(gpointer data, gpointer user_data)
{
net_nfc_error_e result;
net_nfc_target_type_e dev_type;
gpointer user_data)
{
net_nfc_error_e result;
- net_nfc_target_info_h info;
+ net_nfc_target_info_s *info;
result = net_nfc_client_tag_get_current_tag_info_sync(&info);
gpointer user_data)
{
net_nfc_error_e result;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
result = net_nfc_client_tag_get_current_target_handle_sync(&handle);
run_next_callback(user_data);
}
-void net_nfc_test_tag_set_tag_discovered(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_set_tag_discovered(gpointer data, gpointer user_data)
{
g_print("Waiting for TagDiscovered Signal\n");
net_nfc_client_tag_set_tag_discovered(tag_discovered, user_data);
}
-net_nfc_target_info_h net_nfc_test_tag_get_target_info(void)
+net_nfc_target_info_s* net_nfc_test_tag_get_target_info(void)
{
return global_info;
}
-void net_nfc_test_tag_set_tag_detached(gpointer data,
- gpointer user_data)
+void net_nfc_test_tag_set_tag_detached(gpointer data, gpointer user_data)
{
g_print("Waiting for TagDetached Singal\n");
void net_nfc_test_tag_set_tag_discovered(gpointer data,
gpointer user_data);
-net_nfc_target_info_h net_nfc_test_tag_get_target_info(void);
+net_nfc_target_info_s* net_nfc_test_tag_get_target_info(void);
void net_nfc_test_tag_set_tag_detached(gpointer data,
gpointer user_data);
#include "net_nfc_client_tag_felica.h"
-static net_nfc_target_handle_h get_handle();
-
-static void run_next_callback(gpointer user_data);
-
-static void felica_cb(net_nfc_error_e result, data_h resp_data, void *user_data);
-
-
-static net_nfc_target_handle_h get_handle()
+static net_nfc_target_handle_s* get_handle()
{
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
}
}
-static void felica_cb(net_nfc_error_e result, data_h resp_data, void *user_data)
+static void felica_cb(net_nfc_error_e result, data_s *resp_data, void *user_data)
{
g_print("felica_cb Completed %d\n", result);
void net_nfc_test_felica_poll(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
net_nfc_felica_poll_request_code_e req_code = 0x00;
uint8_t time_slot = 2;
void net_nfc_test_felica_request_service(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t number_of_area_service = 4;
uint16_t area_service_list[10] = { 0,};
uint8_t number_of_services = 5;
void net_nfc_test_felica_request_response(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = get_handle();
if (handle == NULL)
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t number_of_services = 10;
uint16_t service_list[10] = {0,};
uint8_t number_of_blocks = 1;
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t number_of_services = 10;
uint16_t service_list[10] = {0,};
uint8_t number_of_blocks = 1;
uint8_t block_list[3] = {0,};
- data_h data_to_write = NULL;
+ data_s *data_to_write = NULL;
handle = get_handle();
if (handle == NULL)
void net_nfc_test_felica_request_system_code(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
handle = get_handle();
if (handle == NULL)
void net_nfc_test_felica_poll(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_felica_request_service(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_felica_request_response(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_felica_read_without_encryption(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_felica_write_without_encryption(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_felica_request_system_code(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif
#include "net_nfc_test_util.h"
-static net_nfc_target_handle_h tag_get_handle(void);
+static net_nfc_target_handle_s* tag_get_handle(void);
-static void mifare_read_cb(net_nfc_error_e result,
- data_h resp_data,
- void *user_data);
+static void mifare_read_cb(net_nfc_error_e result, data_s *resp_data, void *user_data);
static void mifare_write_block_cb(net_nfc_error_e result, void* user_data);
static void mifare_write_auth_keyB_cb(net_nfc_error_e result, void* user_data);
-static net_nfc_target_handle_h tag_get_handle(void)
+static net_nfc_target_handle_s* tag_get_handle(void)
{
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
}
static void mifare_read_cb(net_nfc_error_e result,
- data_h resp_data,
+ data_s *resp_data,
void *user_data)
{
g_print("mifare_read_cb Completed %d\n", result);
void net_nfc_test_tag_mifare_read(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block_index = 0x0;
handle = tag_get_handle();
void net_nfc_test_tag_mifare_write_block(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
- data_h write_data = NULL;
+ net_nfc_target_handle_s *handle = NULL;
+ data_s *write_data = NULL;
// create 4 bytes data mifare page size is 4 bytes
uint8_t buffer_data [17] = "aaaabbbbccccdddd";
result = net_nfc_client_mifare_write_block(handle,
block_index,
- (data_h)& write_data,
+ write_data,
mifare_write_block_cb,
user_data);
void net_nfc_test_tag_mifare_write_page(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
- data_h write_data = NULL;
+ net_nfc_target_handle_s *handle = NULL;
+ data_s *write_data = NULL;
// create 4 bytes data mifare page size is 4 bytes
uint8_t buffer_data [5] = "aaaa";
result = net_nfc_client_mifare_write_page(handle,
block_index,
- (data_h)& write_data,
+ write_data,
mifare_write_page_cb,
user_data);
void net_nfc_test_tag_mifare_increment(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
int value = 1;
uint8_t block_index = 0x05;
void net_nfc_test_tag_mifare_decrement(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
int value = 1;
uint8_t block_index = 0x05;
void net_nfc_test_tag_mifare_transfer(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block_index = 0x08;
handle = tag_get_handle();
void net_nfc_test_tag_mifare_restore(gpointer data, gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
uint8_t block_index = 0x08;
handle = tag_get_handle();
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
- data_h auth_key = NULL;
+ net_nfc_target_handle_s *handle = NULL;
+ data_s *auth_key = NULL;
uint8_t sector_index = 0x02;
handle = tag_get_handle();
gpointer user_data)
{
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
- data_h auth_key = NULL;
+ net_nfc_target_handle_s *handle = NULL;
+ data_s *auth_key = NULL;
uint8_t sector_index = 0x02;
handle = tag_get_handle();
void net_nfc_test_tag_mifare_read(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_authenticate_with_keyA(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_authenticate_with_keyB(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_write_block(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_write_page(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_increment(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_decrement(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_transfer(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_restore(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_create_default_key(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_tag_mifare_create_net_nfc_forum_key(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif
static void call_transceive_data_cb(net_nfc_error_e result,
- data_h resp_data,
+ data_s *resp_data,
void *user_data);
static void call_transceive_cb(net_nfc_error_e result,
}
static void call_transceive_data_cb(net_nfc_error_e result,
- data_h resp_data,
+ data_s *resp_data,
void *user_data)
{
g_print("call_transceive_data_cb Completed %d\n", result);
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
net_nfc_get_tag_handle(info, &handle);
result =net_nfc_client_transceive(handle,
- (data_h)&raw_data,
+ &raw_data,
call_transceive_cb,
user_data);
g_print("net_nfc_client_transceive() : %d\n", result);
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
net_nfc_get_tag_handle(info, &handle);
- result = net_nfc_client_transceive_sync(handle, (data_h)& raw_data);
+ result = net_nfc_client_transceive_sync(handle, &raw_data);
g_print("Transceive Sync is completed(%d)\n", result);
}
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL,};
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
net_nfc_get_tag_handle(info, &handle);
result = net_nfc_client_transceive_data(handle,
- (data_h) &raw_data,
+ &raw_data,
call_transceive_data_cb,
user_data);
g_print("net_nfc_client_transceive_data() : %d\n", result);
{
net_nfc_error_e result = NET_NFC_OK;
data_s raw_data = {NULL};
- data_h response = NULL;
- net_nfc_target_info_h info = NULL;
- net_nfc_target_handle_h handle = NULL;
+ data_s *response = NULL;
+ net_nfc_target_info_s *info = NULL;
+ net_nfc_target_handle_s *handle = NULL;
info = net_nfc_test_tag_get_target_info();
void net_nfc_test_transceive(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_transceive_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_transceive_data(gpointer data,
- gpointer user_data);
+ gpointer user_data);
void net_nfc_test_transceive_data_sync(gpointer data,
- gpointer user_data);
+ gpointer user_data);
#endif
#include "net_nfc_test_util.h"
-void print_received_data(data_h data)
+void print_received_data(data_s *data)
{
guint8 *buffer = NULL;
gint i;
#include "net_nfc_data.h"
-void print_received_data(data_h data);
+void print_received_data(data_s *data);
#endif
#if 1
- ndef_message_h ndef_message = NULL;
+ ndef_message_s *ndef_message = NULL;
net_nfc_conn_handover_info_h conn_handover_info = NULL;
int i = 0;
while(i < count)
{
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
net_nfc_get_record_by_index(ndef_message, i++, &record);
if (record != NULL)
{
net_nfc_record_tnf_e TNF = NET_NFC_RECORD_EMPTY;
- data_h record_type = NULL;
+ data_s *record_type = NULL;
if ((net_nfc_get_record_tnf(record, &TNF) == NET_NFC_OK)
&& (net_nfc_get_record_type(record, &record_type) == NET_NFC_OK ))
if(carrier_info != NULL)
{
- data_h configuration = NULL;
+ data_s *configuration = NULL;
net_nfc_get_carrier_configuration(carrier_info, &configuration);
if(configuration != NULL)
}
__attribute__((packed)) net_nfc_certificate_chain_s;
-void _display_ndef_message(ndef_message_h msg);
+void _display_ndef_message(ndef_message_s *msg);
static void _display_buffer(char *title, uint8_t *buffer, uint32_t length)
{
int32_t i;
- if (length > 0)
+ if (0 < length)
{
fprintf(stdout, " %s[%d] = {", title, length);
}
}
-static void _display_id(ndef_record_h record)
+static void _display_id(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
net_nfc_get_record_id(record, &data);
if (net_nfc_get_data_length(data) > 0)
}
}
-static void _display_signature(ndef_record_h record)
+static void _display_signature(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_smart_poster(ndef_record_h record)
+static void _display_smart_poster(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_text(ndef_record_h record)
+static void _display_text(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
net_nfc_encode_type_e encoding = 0;
_display_id(record);
}
}
-static void _display_uri(ndef_record_h record)
+static void _display_uri(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_hs(ndef_record_h record)
+static void _display_hs(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
(*buffer) & 0x0F);
fprintf(stdout, " -- Containing NDEF message -- \n");
- ndef_message_h msg;
- data_h temp;
+ ndef_message_s *msg;
+ data_s *temp;
net_nfc_create_data(&temp, buffer + 1, length - 1);
net_nfc_create_ndef_message_from_rawdata(&msg, temp);
}
}
-static void _display_hr(ndef_record_h record)
+static void _display_hr(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
(*buffer) & 0x0F);
fprintf(stdout, " -- Containing NDEF message -- \n");
- ndef_message_h msg;
- data_h temp;
+ ndef_message_s *msg;
+ data_s *temp;
net_nfc_create_data(&temp, buffer + 1, length - 1);
net_nfc_create_ndef_message_from_rawdata(&msg, temp);
}
}
-static void _display_ac(ndef_record_h record)
+static void _display_ac(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_hc(ndef_record_h record)
+static void _display_hc(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_cr(ndef_record_h record)
+static void _display_cr(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_err(ndef_record_h record)
+static void _display_err(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
}
-static void _display_well_known(ndef_record_h record)
+static void _display_well_known(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
net_nfc_get_record_type(record, &data);
if (net_nfc_get_data_length(data) > 0)
}
}
-static void _display_general_record(ndef_record_h record)
+static void _display_general_record(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
net_nfc_get_record_type(record, &data);
if (net_nfc_get_data_length(data) > 0)
}
}
-static void _display_absolute_uri(ndef_record_h record)
+static void _display_absolute_uri(ndef_record_s *record)
{
- data_h data = NULL;
+ data_s *data = NULL;
_display_id(record);
}
#if 0
nfc_ndef_record_get_payload(record, &buffer, &length);
- if (length > 0)
+ if (0 < length)
{
char temp_buffer[512] = { 0, };
#endif
}
-static void _display_tnf(ndef_record_h record)
+static void _display_tnf(ndef_record_s *record)
{
net_nfc_record_tnf_e tnf = NET_NFC_RECORD_UNKNOWN;
}
}
-static void _display_record_length(ndef_record_h record)
+static void _display_record_length(ndef_record_s *record)
{
int length = 2; /* header : 1 byte, type length : 1 byte */
tnf != NET_NFC_RECORD_UNKNOWN &&
tnf != NET_NFC_RECORD_UNCHAGNED)
{
- data_h data;
+ data_s *data;
net_nfc_get_record_type(record, &data);
length += net_nfc_get_data_length(data);
/* for non empty record */
if (tnf != NET_NFC_RECORD_EMPTY)
{
- data_h data;
+ data_s *data;
net_nfc_get_record_payload(record, &data);
length += net_nfc_get_data_length(data);
/* ID and IDlength are present only if IL flag is set*/
if (net_nfc_get_record_il(header) == 1)
{
- data_h data;
+ data_s *data;
/* ++ is for the ID Length Byte */
length++;
fprintf(stdout, " Length : %d\n", length);
}
-static void _display_record(ndef_record_h record, int index)
+static void _display_record(ndef_record_s *record, int index)
{
uint8_t header;
fprintf(stdout, "----------------------------------------------------\n");
}
-void _display_ndef_message(ndef_message_h msg)
+void _display_ndef_message(ndef_message_s *msg)
{
uint32_t length;
int count = 0;
int32_t i = 0;
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
net_nfc_get_ndef_message_byte_length(msg, &length);
void ndef_tool_display_ndef_message_from_file(const char *file_name)
{
int length = 0;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if ((length = ndef_tool_read_ndef_message_from_file(file_name, &msg)) > 0)
{
fprintf(stdout, "Target Type : %s (%d)\n", text, type);
}
-void _display_tag_info(net_nfc_target_info_h target)
+void _display_tag_info(net_nfc_target_info_s *target)
{
int count, i;
char **keys;
- data_h data;
+ data_s *data;
fprintf(stdout, "Target information\n");
net_nfc_get_tag_info_keys(target, &keys, &count);
}
}
-void ndef_tool_display_discovered_tag(net_nfc_target_info_h target)
+void ndef_tool_display_discovered_tag(net_nfc_target_info_s *target)
{
net_nfc_target_type_e type;
bool is_ndef;
fprintf(stdout, "******************************************\n");
}
-void ndef_tool_display_discovered_target(net_nfc_target_handle_h handle)
+void ndef_tool_display_discovered_target(net_nfc_target_handle_s *handle)
{
if (handle == NULL)
return;
bool ndef_tool_sign_message_from_file(const char *file_name, int begin_index, int end_index, char *cert_file, char *password)
{
bool result = false;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
int32_t count = 0;
if (ndef_tool_read_ndef_message_from_file(file_name, &msg) > 0)
bool ndef_tool_verify_message_from_file(const char *file_name)
{
bool result = false;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (ndef_tool_read_ndef_message_from_file(file_name, &msg) > 0)
{
static GMainLoop *main_loop = NULL;
static response_context_t response_context = { 0, };
-static void _tag_read_completed_cb(ndef_message_h msg, void *user_data)
+static void _tag_read_completed_cb(ndef_message_s *msg, void *user_data)
{
response_context_t *context = (response_context_t *)user_data;
g_main_loop_quit(main_loop);
}
-static void _tag_read_cb(net_nfc_target_handle_h handle, void *user_data)
+static void _tag_read_cb(net_nfc_target_handle_s *handle, void *user_data)
{
fprintf(stdout, "\nreading...\n\n");
g_main_loop_quit(main_loop);
}
-static void _tag_write_cb(net_nfc_target_handle_h handle, void *user_data)
+static void _tag_write_cb(net_nfc_target_handle_s *handle, void *user_data)
{
response_context_t *context = (response_context_t *)user_data;
fprintf(stdout, "\nwriting...\n\n");
- net_nfc_write_ndef(handle, (ndef_message_h)context->user_param, user_data);
+ net_nfc_client_ndef_write(handle, (ndef_message_s*)context->user_param, user_data);
}
-static void _p2p_receive_completed_cb(data_h data, void *user_data)
+static void _p2p_receive_completed_cb(data_s *data, void *user_data)
{
response_context_t *context = (response_context_t *)user_data;
fprintf(stdout, "\np2p receive complete!!!\n\n");
if (data != NULL)
{
- ndef_message_h msg;
+ ndef_message_s *msg;
net_nfc_create_ndef_message_from_rawdata(&msg, data);
g_main_loop_quit(main_loop);
}
-static void _p2p_send_cb(net_nfc_target_handle_h handle, void *user_data)
+static void _p2p_send_cb(net_nfc_target_handle_s *handle, void *user_data)
{
response_context_t *context = (response_context_t *)user_data;
data_s *rawdata;
- net_nfc_create_rawdata_from_ndef_message((ndef_message_h)context->user_param, &rawdata);
+ net_nfc_create_rawdata_from_ndef_message((ndef_message_s*)context->user_param, &rawdata);
/* FIXME */
net_nfc_free_data(rawdata);
}
static void _handover_completed_cb(net_nfc_error_e result,
- data_h data, void *user_data)
+ data_s *data, void *user_data)
{
// response_context_t *context = (response_context_t *)user_data;
- // data_h rawdata;
+ // data_s *rawdata;
if (result == NET_NFC_OK)
fprintf(stdout, "handover success!!!\n\n");
else
fprintf(stdout, "handover failed.\n\n");
- // net_nfc_create_rawdata_from_ndef_message((ndef_message_h)context->user_param, &rawdata);
+ // net_nfc_create_rawdata_from_ndef_message((ndef_message_s*)context->user_param, &rawdata);
//
// net_nfc_ex
g_main_loop_quit(main_loop);
}
-static void _open_se_cb(net_nfc_error_e result, net_nfc_target_handle_h handle,
+static void _open_se_cb(net_nfc_error_e result, net_nfc_target_handle_s *handle,
void *user_data)
{
response_context_t *context = (response_context_t *)user_data;
if (result == NET_NFC_OK)
{
- data_h data = NULL;
+ data_s *data = NULL;
fprintf(stdout, "net_nfc_open_internal_secure_element success!!!\n\n");
}
}
-static void _send_apdu_se_cb(net_nfc_error_e result, net_nfc_target_handle_h handle, void *user_data)
+static void _send_apdu_se_cb(net_nfc_error_e result, net_nfc_target_handle_s *handle, void *user_data)
{
// response_context_t *context = (response_context_t *)user_data;
- // data_h rawdata;
+ // data_s *rawdata;
if (result == NET_NFC_OK)
{
g_main_loop_quit(main_loop);
}
-static void _handover_cb(net_nfc_target_handle_h handle, void *user_data)
+static void _handover_cb(net_nfc_target_handle_s *handle, void *user_data)
{
fprintf(stdout, "\ntry to handover...\n\n");
{
case NET_NFC_MESSAGE_TAG_DISCOVERED :
{
- net_nfc_target_handle_h handle = NULL;
+ net_nfc_target_handle_s *handle = NULL;
bool is_ndef = false;
- net_nfc_get_tag_handle((net_nfc_target_info_h)data, &handle);
- net_nfc_get_tag_ndef_support((net_nfc_target_info_h)data, &is_ndef);
+ net_nfc_get_tag_handle((net_nfc_target_info_s*)data, &handle);
+ net_nfc_get_tag_ndef_support((net_nfc_target_info_s*)data, &is_ndef);
ndef_tool_display_discovered_tag(data);
break;
case NET_NFC_MESSAGE_READ_NDEF :
- _tag_read_completed_cb((ndef_message_h)data, user_param);
+ _tag_read_completed_cb((ndef_message_s*)data, user_param);
break;
case NET_NFC_MESSAGE_WRITE_NDEF :
if (context->type == 1) /* receive */
{
- _p2p_send_cb((net_nfc_target_handle_h)data, user_param);
+ _p2p_send_cb((net_nfc_target_handle_s*)data, user_param);
}
else if (context->type == 2) /* handover */
{
- _handover_cb((net_nfc_target_handle_h)data, user_param);
+ _handover_cb((net_nfc_target_handle_s*)data, user_param);
}
break;
int ndef_tool_write_ndef_to_tag(const char *file)
{
int result = 0;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (ndef_tool_read_ndef_message_from_file(file, &msg) > 0)
{
int ndef_tool_send_ndef_via_p2p(const char *file)
{
int result = 0;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (ndef_tool_read_ndef_message_from_file(file, &msg) > 0)
{
return result;
}
-static int _make_file_to_ndef_message(ndef_message_h *msg, const char *file_name)
+static int _make_file_to_ndef_message(ndef_message_s **msg, const char *file_name)
{
int result = 0;
FILE *file = NULL;
if (file_size > 0)
{
- data_h data;
+ data_s *data;
net_nfc_create_data(&data, NULL, file_size);
if (data != NULL)
{
- ndef_record_h record;
- data_h type;
+ ndef_record_s *record;
+ data_s *type;
read = fread((void *)net_nfc_get_data_buffer(data), 1, file_size, file);
int ndef_tool_connection_handover(const char *file)
{
int result = 0;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (_make_file_to_ndef_message(&msg, file) > 0)
{
}
}
-int ndef_tool_read_ndef_message_from_file(const char *file_name, ndef_message_h *msg)
+int ndef_tool_read_ndef_message_from_file(const char *file_name, ndef_message_s **msg)
{
int result = -1;
FILE *file = NULL;
if (file_size > 0)
{
- data_h data;
+ data_s *data;
net_nfc_create_data(&data, NULL, file_size);
if (data != NULL)
return result;
}
-int ndef_tool_write_ndef_message_to_file(const char *file_name, ndef_message_h msg)
+int ndef_tool_write_ndef_message_to_file(const char *file_name, ndef_message_s *msg)
{
int result = -1;
FILE *file = NULL;
- data_h data = NULL;
+ data_s *data = NULL;
net_nfc_create_rawdata_from_ndef_message(msg, &data);
if (data != NULL)
return result;
}
-static int _append_record_to_file(const char *file_name, ndef_record_h record)
+static int _append_record_to_file(const char *file_name, ndef_record_s *record)
{
int result = -1;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (ndef_tool_read_ndef_message_from_file(file_name, &msg) <= 0)
{
return result;
}
-ndef_record_h _create_record(net_nfc_record_tnf_e tnf, data_h type, data_h id , data_h payload, char *encoding)
+ndef_record_s* _create_record(net_nfc_record_tnf_e tnf, data_s *type, data_s *id , data_s *payload, char *encoding)
{
- ndef_record_h result = NULL;
+ ndef_record_s *result = NULL;
switch (tnf)
{
bool _remove_record_from_file(const char *file_name, int index)
{
bool result = false;
- ndef_message_h msg = NULL;
+ ndef_message_s *msg = NULL;
if (ndef_tool_read_ndef_message_from_file(file_name, &msg) > 0)
{
int end_index = -1;
int operation = OPERATION_ERROR;
net_nfc_record_tnf_e tnf = -1;
- data_h type = NULL;
- data_h id = NULL;
- data_h payload = NULL;
+ data_s *type = NULL;
+ data_s *id = NULL;
+ data_s *payload = NULL;
char *file_name = NULL;
char *cert_file = NULL;
char *password = NULL;
char *encoding = NULL;
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
int i = 1;
int len = 0;
/*
- * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Flora License, Version 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+ * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#ifndef __NDEF_TOOL_H__
#define __NDEF_TOOL_H__
OPERATION_SET_SE, /* hidden operation */
};
-int ndef_tool_read_ndef_message_from_file(const char *file_name, ndef_message_h *msg);
-int ndef_tool_write_ndef_message_to_file(const char *file_name, ndef_message_h msg);
+int ndef_tool_read_ndef_message_from_file(const char *file_name, ndef_message_s **msg);
+int ndef_tool_write_ndef_message_to_file(const char *file_name, ndef_message_s *msg);
void ndef_tool_display_ndef_message_from_file(const char *file_name);
-void ndef_tool_display_discovered_tag(net_nfc_target_info_h target);
-void ndef_tool_display_discovered_target(net_nfc_target_handle_h handle);
+void ndef_tool_display_discovered_tag(net_nfc_target_info_s *target);
+void ndef_tool_display_discovered_target(net_nfc_target_handle_s *handle);
bool ndef_tool_sign_message_from_file(const char *file_name, int begin_index, int end_index, char *cert_file, char *password);
bool ndef_tool_verify_message_from_file(const char *file_name);
static int write_count = 0;
static int detect_count = 0;
-static net_nfc_target_handle_h tag_handle = NULL;
+static net_nfc_target_handle_s *tag_handle = NULL;
static int test_count = 0;
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:{
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle(target_info, &id);
}
case NET_NFC_MESSAGE_READ_NDEF:{
if(data != NULL){
- ndef_message_h ndef = (ndef_message_h)(data);
- data_h rawdata;
+ ndef_message_s *ndef = (ndef_message_s*)data;
+ data_s *rawdata;
net_nfc_create_rawdata_from_ndef_message (ndef ,&rawdata);
PRINT_INFO("read ndef message is ok, length is [%d]", net_nfc_get_data_length(rawdata));
net_nfc_free_data(rawdata);
PRINT_INFO("NET_NFC_MESSAGE_TAG_DISCOVERED");
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle(target_info, &id);
PRINT_INFO("target id: %X\n", (unsigned int)id);
PRINT_INFO("Is NDEF supoort: %d\n", is_ndef);
- data_h ndef_key = NULL;
+ data_s *ndef_key = NULL;
net_nfc_mifare_create_net_nfc_forum_key(&ndef_key);
net_nfc_format_ndef(id, ndef_key, NULL);
net_nfc_free_data(ndef_key);
case NET_NFC_MESSAGE_OPEN_INTERNAL_SE :
{
PRINT_INFO("NET_NFC_MESSAGE_OPEN_INTERNAL_SE result = [%d] and handle = [0x%x]", result, (unsigned int)data);
- data_h apdu = NULL;
+ data_s *apdu = NULL;
uint8_t apdu_cmd[4] = {0x00, 0xA4, 0x00, 0x0C} ; // CLA 0-> use default channel and no secure message. 0xA4 -> select instruction
net_nfc_create_data(&apdu, apdu_cmd, 4);
- net_nfc_send_apdu((net_nfc_target_handle_h)(data), apdu, data);
+ net_nfc_send_apdu((net_nfc_target_handle_s*)data, apdu, data);
net_nfc_free_data(apdu);
}
}printf ("\n");
}
- net_nfc_close_internal_secure_element((net_nfc_target_handle_h)trans_data, NULL);
+ net_nfc_close_internal_secure_element((net_nfc_target_handle_s*)trans_data, NULL);
}
break;
case NET_NFC_MESSAGE_CLOSE_INTERNAL_SE :
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:{
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
- net_nfc_carrier_config_h config;
- ndef_record_h record;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
+ net_nfc_carrier_config_s *config;
+ ndef_record_s *record;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle(target_info, &id);
if (is_ndef){
- ndef_message_h ndef = NULL;
- data_h bt_config = NULL;
+ ndef_message_s *ndef = NULL;
+ data_s *bt_config = NULL;
net_nfc_create_data_only(&bt_config);
// 2byte :: OOB length, 6byte :: bt addr
#else
/*
- ndef_message_h ndef = NULL;
+ ndef_message_s *ndef = NULL;
if(net_nfc_retrieve_current_ndef_message(&ndef) == NET_NFC_OK){
PRINT_INFO("retrieve is ok");
return NET_NFC_TEST_FAIL;
}
*/
- ndef_message_h ndef = NULL;
- data_h bt_config = NULL;
+ ndef_message_s *ndef = NULL;
+ data_s *bt_config = NULL;
net_nfc_create_data_only(&bt_config);
// 2byte :: OOB length, 6byte :: bt addr
PRINT_INFO("get random_number is failed = [%d]", result);
}
- data_h record_type = NULL;
+ data_s *record_type = NULL;
net_nfc_get_connection_handover_record_type(handover_info, &record_type);
PRINT_INFO("record type = [%c] [%c]", (net_nfc_get_data_buffer(record_type))[0], (net_nfc_get_data_buffer(record_type))[1]);
PRINT_INFO("carrier is unknown");
}
- data_h id = NULL;
+ data_s *id = NULL;
net_nfc_get_carrier_id(carrier_info, &id);
PRINT_INFO("id = [0x%x]", (net_nfc_get_data_buffer(id))[0]);
PRINT_INFO("cps is = [0x%x]", carrier_state);
- data_h config = NULL;
+ data_s *config = NULL;
if((result = net_nfc_get_carrier_configuration(carrier_info, &config)) == NET_NFC_OK)
{
PRINT_INFO("good to get config");
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:{
net_nfc_target_type_e type;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle (target_info, &handle);
if (is_ndef){
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
if( (error = net_nfc_create_uri_type_record(&record, "http://www.samsung.com", NET_NFC_SCHEMA_FULL_URI)) == NET_NFC_OK)
{
{
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
if( (error = net_nfc_create_text_type_record(&record, "This is real NFC", "en-US", NET_NFC_ENCODE_UTF_8)) == NET_NFC_OK)
{
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:{
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_error_e result = NET_NFC_OK;
net_nfc_get_tag_type (target_info, &type);
else if(type >= NET_NFC_MIFARE_MINI_PICC && type <= NET_NFC_MIFARE_4K_PICC){
- data_h mad_key = NULL;
- data_h net_nfc_forum_key = NULL;
- data_h default_key = NULL;
+ data_s *mad_key = NULL;
+ data_s *net_nfc_forum_key = NULL;
+ data_s *default_key = NULL;
net_nfc_mifare_create_application_directory_key(&mad_key);
net_nfc_mifare_create_net_nfc_forum_key(&net_nfc_forum_key);
int sector = 1;
- data_h key = NULL;
+ data_s *key = NULL;
test_count = 4;
if(sector == 0){
}
*/
/*
- data_h write_block = NULL;
+ data_s *write_block = NULL;
uint8_t buffer[16] = {0x00,};
uint8_t* temp = buffer;
*/
/*
- data_h write_block = NULL;
+ data_s *write_block = NULL;
uint8_t buffer[16] = {0x00, 0x00, 0x03, 0xE8, 0xFF, 0xFF, 0xFC, 0x18, 0x00, 0x00, 0x03, 0xE8, 0x05, 0xFB, 0x05, 0xFB};
net_nfc_create_data(&write_block, buffer, 16);
if(test_count == 0){
int idx;
- data_h r_data = (data_h) data;
+ data_s *r_data = (data_s*)data;
uint8_t * r_buffer = net_nfc_get_data_buffer (r_data);
uint32_t r_buffer_length = net_nfc_get_data_length (r_data);
}
else if(test_count == 1){
int idx;
- data_h r_data = (data_h) data;
+ data_s *r_data = (data_s*)data;
uint8_t * r_buffer = net_nfc_get_data_buffer (r_data);
uint32_t r_buffer_length = net_nfc_get_data_length (r_data);
}
else if(test_count == 2){
int idx;
- data_h r_data = (data_h) data;
+ data_s *r_data = (data_s*)data;
uint8_t * r_buffer = net_nfc_get_data_buffer (r_data);
uint32_t r_buffer_length = net_nfc_get_data_length (r_data);
}
else if(test_count == 3){
int idx;
- data_h r_data = (data_h) data;
+ data_s *r_data = (data_s*)data;
uint8_t * r_buffer = net_nfc_get_data_buffer (r_data);
uint32_t r_buffer_length = net_nfc_get_data_length (r_data);
else if(test_count == 4){
int idx;
- data_h r_data = (data_h) data;
+ data_s *r_data = (data_s*)data;
uint8_t * r_buffer = net_nfc_get_data_buffer (r_data);
uint32_t r_buffer_length = net_nfc_get_data_length (r_data);
static void* net_nfc_read_ndef_test(void* handle)
{
- net_nfc_target_handle_h target_handle = (net_nfc_target_handle_h)handle;
+ net_nfc_target_handle_s *target_handle = (net_nfc_target_handle_s*)handle;
int count = 0;
for (count = 0; count < REQUEST_PER_THREAD ; count ++)
case NET_NFC_MESSAGE_TAG_DISCOVERED:
{
net_nfc_target_type_e type;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle (target_info, &handle);
PRINT_INFO("read ndef msg");
number_of_read_completed ++;
- //ndef_message_h ndef = (ndef_message_h)(data);
+ //ndef_message_s *ndef = (ndef_message_s*)data;
////net_nfc_ndef_print_message(ndef);
case NET_NFC_MESSAGE_TAG_DISCOVERED:
{
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle (target_info, &id);
{
PRINT_INFO("key [%s]", keys[i]);
- data_h value = NULL;
+ data_s *value = NULL;
if((error = net_nfc_get_tag_info_value(target_info, keys[i], &value)) == NET_NFC_OK)
{
int index = 0;
static void* net_nfc_read_stress_ndef_test(void* handle)
{
- net_nfc_target_handle_h target_handle = (net_nfc_target_handle_h)handle;
+ net_nfc_target_handle_s *target_handle = (net_nfc_target_handle_s*)handle;
int count = 0;
for (count = 0; count < 200 ; count ++)
case NET_NFC_MESSAGE_TAG_DISCOVERED:
{
net_nfc_target_type_e type;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle (target_info, &handle);
{
if(data != NULL){
- //ndef_message_h ndef = (ndef_message_h)(data);
+ //ndef_message_s *ndef = (ndef_message_s*)data;
////net_nfc_ndef_print_message(ndef);
case NET_NFC_MESSAGE_TAG_DISCOVERED:
{
net_nfc_target_type_e type;
- net_nfc_target_handle_h handle;
+ net_nfc_target_handle_s *handle;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
net_nfc_get_tag_type (target_info, &type);
net_nfc_get_tag_handle (target_info, &handle);
}
if(data != NULL){
- //ndef_message_h ndef = (ndef_message_h)(data);
+ //ndef_message_s *ndef = (ndef_message_s*)data;
////net_nfc_ndef_print_message(ndef);
test_case_result = NET_NFC_TEST_OK;
net_nfc_error_e error = NET_NFC_OK;
- ndef_message_h msg = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *msg = NULL;
+ ndef_record_s *record = NULL;
if( (error = net_nfc_create_text_type_record(&record, "This is real NFC", "en-US", NET_NFC_ENCODE_UTF_8)) == NET_NFC_OK)
{
//net_nfc_error_e result;
test_case_result = NET_NFC_TEST_FAIL;
- ndef_message_h ndef_message = NULL;
+ ndef_message_s *ndef_message = NULL;
if(net_nfc_retrieve_current_ndef_message(&ndef_message) == NET_NFC_OK)
{
int i = 0;
for(; i < count; i++)
{
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
if(net_nfc_get_record_by_index(ndef_message, i, &record) == NET_NFC_OK)
{
net_nfc_record_tnf_e tnf;
{
case NET_NFC_RECORD_WELL_KNOWN_TYPE:
{
- data_h type = NULL;
- data_h payload = NULL;
+ data_s *type = NULL;
+ data_s *payload = NULL;
if(net_nfc_get_record_type(record, &type) == NET_NFC_OK && net_nfc_get_record_payload(record, &payload) == NET_NFC_OK)
{
{
net_nfc_error_e result;
- ndef_message_h uriMsg = NULL;
- ndef_message_h spMsg = NULL;
- ndef_record_h uriRecord = NULL;
- ndef_record_h spRecord = NULL;
- data_h type_data = NULL;
- data_h raw_data = NULL;
+ ndef_message_s *uriMsg = NULL;
+ ndef_message_s *spMsg = NULL;
+ ndef_record_s *uriRecord = NULL;
+ ndef_record_s *spRecord = NULL;
+ data_s *type_data = NULL;
+ data_s *raw_data = NULL;
char smart_poster_type[] = "Sp";
- ndef_record_h record = NULL;
+ ndef_record_s *record = NULL;
test_case_result = NET_NFC_TEST_OK;
result = net_nfc_create_ndef_message (&uriMsg);
case NET_NFC_MESSAGE_LLCP_CONNECT:
{
PRINT_INFO ("LLCP connect is completed with error code %d", result);
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
net_nfc_send_llcp (client_socket, data, NULL);
case NET_NFC_MESSAGE_LLCP_RECEIVE:
PRINT_INFO ("LLCP receive is completed with error code %d", result);
- data_h received_data = (data_h) data;
+ data_s *received_data = (data_s*)data;
PRINT_INFO ("Server --> Client : %s" , net_nfc_get_data_buffer (received_data));
net_nfc_disconnect_llcp (client_socket ,NULL);
case NET_NFC_MESSAGE_LLCP_RECEIVE:
{
PRINT_INFO ("LLCP receive is completed with error code %d", result);
- data_h received_data = (data_h) data;
+ data_s *received_data = (data_s*)data;
PRINT_INFO ("Server <-- Client : %s" , net_nfc_get_data_buffer (received_data));
- data_h data;
+ data_s *data;
char * str = "Server message: Welcome NFC llcp world!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
net_nfc_send_llcp (accepted_socket, data, NULL);
}
}
-net_nfc_target_handle_h snep_handle;
+net_nfc_target_handle_s *snep_handle;
int temp_count;
static void net_nfc_test_snep_cb(net_nfc_message_e message, net_nfc_error_e result, void* data, void* user_param, void * trans_data)
#if 0
case NET_NFC_MESSAGE_P2P_DISCOVERED:
{
- snep_handle = (net_nfc_target_handle_h) data;
- //= (net_nfc_target_handle_h) target_info->handle;
+ snep_handle = (net_nfc_target_handle_s*) data;
+ //= (net_nfc_target_handle_s*) target_info->handle;
/* Fill the data to send. */
if(NET_NFC_OK == net_nfc_create_exchanger_data(&snep_ex_data, nfcTestUri))
case NET_NFC_MESSAGE_P2P_RECEIVE:
{
// int i;
-// data_h received_data = (data_h)data;
+// data_s *received_data = (data_s*)data;
// PRINT_INFO ("NET_NFC_MESSAGE_P2P_RECEIVE [%s]", net_nfc_get_data_buffer(received_data));
// PRINT_INFO (" length [%d]", net_nfc_get_data_length(received_data));
switch (message) {
case NET_NFC_MESSAGE_LLCP_DISCOVERED:
{
- net_nfc_llcp_config_info_h config = (net_nfc_llcp_config_info_h) data;
+ net_nfc_llcp_config_info_s *config = (net_nfc_llcp_config_info_s*)data;
uint8_t lto, option;
uint16_t wks, miu;
net_nfc_get_llcp_configure_lto (config , <o);
int nfcTestLLCP(uint8_t testNumber,void* arg_ptr2)
{
net_nfc_error_e result;
- net_nfc_llcp_config_info_h config;
+ net_nfc_llcp_config_info_s *config;
result = net_nfc_client_initialize();
CHECK_RESULT(result);
net_nfc_state_activate ();
case NET_NFC_MESSAGE_LLCP_CONNECT:
{
PRINT_INFO ("LLCP connect is completed with error code %d", result);
- data_h data;
+ data_s *data;
char * str = "Client message: Hello, server!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
net_nfc_send_llcp (client_socket, data, NULL);
case NET_NFC_MESSAGE_LLCP_RECEIVE:
PRINT_INFO ("LLCP receive is completed with error code %d", result);
- data_h received_data = (data_h) data;
+ data_s *received_data = (data_s*)data;
PRINT_INFO ("Server --> Client : %s" , net_nfc_get_data_buffer (received_data));
net_nfc_disconnect_llcp (client_socket ,NULL);
case NET_NFC_MESSAGE_LLCP_RECEIVE:
{
PRINT_INFO ("LLCP receive is completed with error code %d", result);
- data_h received_data = (data_h) data;
+ data_s *received_data = (data_s*)data;
PRINT_INFO ("Server <-- Client : %s" , net_nfc_get_data_buffer (received_data));
- data_h data;
+ data_s *data;
char * str = "Server message: Welcome NFC llcp world!";
net_nfc_create_data (&data, (const uint8_t*)str ,strlen (str) + 1);
net_nfc_send_llcp (server_socket, data, NULL);
switch (message) {
case NET_NFC_MESSAGE_LLCP_DISCOVERED:
{
- net_nfc_llcp_config_info_h config = (net_nfc_llcp_config_info_h) data;
+ net_nfc_llcp_config_info_s *config = (net_nfc_llcp_config_info_s*)data;
uint8_t lto, option;
uint16_t wks, miu;
net_nfc_get_llcp_configure_lto (config , <o);
int nfcTestStressLLCP(uint8_t testNumber,void* arg_ptr2)
{
net_nfc_error_e result;
- net_nfc_llcp_config_info_h config;
- result = net_nfc_initialize();
+ net_nfc_llcp_config_info_s *config;
+ result = net_nfc_client_initialize();
CHECK_RESULT(result);
net_nfc_state_activate ();
result = net_nfc_set_response_callback (net_nfc_test_llcp_stress_cb, NULL);
result = net_nfc_unset_response_callback ();
CHECK_RESULT(result);
- result = net_nfc_deinitialize ();
+ result = net_nfc_client_deinitialize ();
CHECK_RESULT(result);
*/
net_nfc_free_llcp_configure(config);
case 0: // transceive
{
net_nfc_target_type_e type;
- net_nfc_target_handle_h id;
+ net_nfc_target_handle_s *id;
bool is_ndef;
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
//net_nfc_error_e e_ret ;
net_nfc_get_tag_type (target_info, &type);
break;
case 1:
{
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
- net_nfc_target_handle_h id;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
+ net_nfc_target_handle_s *id;
net_nfc_get_tag_handle (target_info, &id);
net_nfc_client_deinitialize();
if (NET_NFC_OK == net_nfc_read_tag (id ,NULL)){
break;
case 2:
{
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
- net_nfc_target_handle_h id;
- ndef_message_h message = NULL;
- ndef_record_h record = NULL;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
+ net_nfc_target_handle_s *id;
+ ndef_message_s *message = NULL;
+ ndef_record_s *record = NULL;
net_nfc_get_tag_handle (target_info, &id);
net_nfc_client_deinitialize();
break;
case 3:
{
- net_nfc_target_info_h target_info = (net_nfc_target_info_h)data;
- net_nfc_target_handle_h id;
- data_h key;
+ net_nfc_target_info_s *target_info = (net_nfc_target_info_s*)data;
+ net_nfc_target_handle_s *id;
+ data_s *key;
char data [] = {0xff,0xff,0xff,0xff,0xff,0xff};
net_nfc_create_data (&key, (const uint8_t*)data, 6);
net_nfc_get_tag_handle (target_info, &id);
/* Call API before initailize */
- data_h key;
+ data_s *key;
net_nfc_error_e result;
uint8_t data [] = {0xff,0xff,0xff,0xff,0xff,0xff};
net_nfc_create_data (&key, data, 6);
- result = net_nfc_format_ndef((net_nfc_target_handle_h) 0x302023, key, NULL);
+ result = net_nfc_format_ndef((net_nfc_target_handle_s*) 0x302023, key, NULL);
if(NET_NFC_OK == result){
net_nfc_free_data(key);
}
CHECK_ASSULT (NET_NFC_OK != result);
result = net_nfc_format_ndef(NULL, key, NULL);
if((NET_NFC_NULL_PARAMETER != result)
- ||(NET_NFC_OK == net_nfc_format_ndef((net_nfc_target_handle_h) 0x302023, NULL, NULL))
- ||(NET_NFC_OK == net_nfc_read_tag ((net_nfc_target_handle_h) 0x302023 ,NULL))
+ ||(NET_NFC_OK == net_nfc_format_ndef((net_nfc_target_handle_s*) 0x302023, NULL, NULL))
+ ||(NET_NFC_OK == net_nfc_read_tag ((net_nfc_target_handle_s*) 0x302023 ,NULL))
||(NET_NFC_NULL_PARAMETER != net_nfc_read_tag (NULL ,NULL)))
{
net_nfc_free_data(key);
}
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == result);
- CHECK_ASSULT (NET_NFC_OK != net_nfc_format_ndef((net_nfc_target_handle_h) 0x302023, NULL, NULL));
+ CHECK_ASSULT (NET_NFC_OK != net_nfc_format_ndef((net_nfc_target_handle_s*) 0x302023, NULL, NULL));
- CHECK_ASSULT (NET_NFC_OK != net_nfc_read_tag ((net_nfc_target_handle_h) 0x302023 ,NULL));
+ CHECK_ASSULT (NET_NFC_OK != net_nfc_read_tag ((net_nfc_target_handle_s*) 0x302023 ,NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_read_tag (NULL ,NULL));
net_nfc_free_data(key);
- ndef_message_h message = NULL;
- ndef_record_h record = NULL;
+ ndef_message_s *message = NULL;
+ ndef_record_s *record = NULL;
net_nfc_create_ndef_message (&message);
net_nfc_create_text_type_record (&record, "abc" ,"en-US" ,NET_NFC_ENCODE_UTF_8);
net_nfc_append_record_to_ndef_message (message ,record);
- result = net_nfc_write_ndef ((net_nfc_target_handle_h)0x302023 ,message,NULL);
+ result = net_nfc_write_ndef ((net_nfc_target_handle_s*)0x302023 ,message,NULL);
if(NET_NFC_OK == result){
net_nfc_free_ndef_message (message);
}
CHECK_ASSULT (NET_NFC_OK != result);
result = net_nfc_write_ndef (NULL ,message,NULL);
- if((NET_NFC_NULL_PARAMETER != result)||(NET_NFC_NULL_PARAMETER != net_nfc_write_ndef ((net_nfc_target_handle_h)0x302023 ,NULL,NULL))){
+ if((NET_NFC_NULL_PARAMETER != result)
+ ||(NET_NFC_NULL_PARAMETER != net_nfc_write_ndef((net_nfc_target_handle_s*)0x302023 ,NULL,NULL)))
+ {
net_nfc_free_ndef_message (message);
}
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == result);
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_write_ndef ((net_nfc_target_handle_h)0x302023 ,NULL,NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_write_ndef((net_nfc_target_handle_s*)0x302023 ,NULL,NULL));
net_nfc_free_ndef_message (message);
char **keys;
int length;
- data_h value;
+ data_s *value;
switch(message)
{
case NET_NFC_MESSAGE_TAG_DISCOVERED:
{
- if (NET_NFC_OK != net_nfc_get_tag_info_keys((net_nfc_target_info_h)data, &keys, &length)){
+ if (NET_NFC_OK != net_nfc_get_tag_info_keys((net_nfc_target_info_s*)data, &keys, &length)){
test_case_result = NET_NFC_TEST_FAIL;
return;
}
- if (NET_NFC_OK == net_nfc_get_tag_info_value ((net_nfc_target_info_h)data, "abc", &value)){
+ if (NET_NFC_OK == net_nfc_get_tag_info_value ((net_nfc_target_info_s*)data, "abc", &value)){
test_case_result = NET_NFC_TEST_FAIL;
return;
}
break;
case NET_NFC_MESSAGE_TAG_DETACHED:
- if (NET_NFC_OK == net_nfc_get_tag_info_keys((net_nfc_target_info_h)data, &keys, &length)){
+ if (NET_NFC_OK == net_nfc_get_tag_info_keys((net_nfc_target_info_s*)data, &keys, &length)){
test_case_result = NET_NFC_TEST_FAIL;
return;
}
int nfcTestAPIException_targetInfo (uint8_t testNumber,void* arg_ptr)
{
net_nfc_target_type_e target_type;
- net_nfc_target_handle_h target_id;
+ net_nfc_target_handle_s *target_id;
bool is_support;
unsigned int size;
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_type ((net_nfc_target_info_h)0x302023, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_type ((net_nfc_target_info_s*)0x302023, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_type (NULL, &target_type));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_handle((net_nfc_target_info_h)0x302023, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_handle((net_nfc_target_info_s*)0x302023, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_handle(NULL, &target_id));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_ndef_support ((net_nfc_target_info_h)0x302023, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_ndef_support ((net_nfc_target_info_s*)0x302023, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_ndef_support (NULL, &is_support));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_max_data_size ((net_nfc_target_info_h)0x302023, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_max_data_size ((net_nfc_target_info_s*)0x302023, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_max_data_size (NULL, &size));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_actual_data_size ((net_nfc_target_info_h)0x302023, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_actual_data_size ((net_nfc_target_info_s*)0x302023, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_actual_data_size (NULL, &size));
char **keys;
int length;
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_keys((net_nfc_target_info_h)0x302023, NULL, &length));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_keys((net_nfc_target_info_h)0x302023, &keys, NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_keys((net_nfc_target_info_s*)0x302023, NULL, &length));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_keys((net_nfc_target_info_s*)0x302023, &keys, NULL));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_keys(NULL, &keys, &length));
const char* key = "hello";
- data_h value;
+ data_s *value;
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_value((net_nfc_target_info_h)0x302023, key , NULL));
- CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_value((net_nfc_target_info_h)0x302023, NULL, &value));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_value((net_nfc_target_info_s*)0x302023, key , NULL));
+ CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_value((net_nfc_target_info_s*)0x302023, NULL, &value));
CHECK_ASSULT (NET_NFC_NULL_PARAMETER == net_nfc_get_tag_info_value(NULL, key, &value));
CHECK_ASSULT(net_nfc_client_initialize() == NET_NFC_OK);
int nfcConnHandoverMessageTest (uint8_t testNumber,void* arg_ptr)
{
- net_nfc_carrier_config_h carrier;
- net_nfc_property_group_h group;
- ndef_record_h carrier_record;
- ndef_message_h message;
+ net_nfc_carrier_config_s *carrier;
+ net_nfc_carrier_property_s *group;
+ ndef_record_s *carrier_record;
+ ndef_message_s *message;
uint8_t buffer[256] = {0,};
uint8_t * pdata;
unsigned int length = 0;
/*
- * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Flora License, Version 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://floralicense.org/license/
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+ * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
#ifndef __NFC_API_TEST_H__
#define __NFC_API_TEST_H__
}net_nfc_test_result_e;
-#define LOG_COLOR_RED "\033[0;31m"
-#define LOG_COLOR_GREEN "\033[0;32m"
-#define LOG_COLOR_BROWN "\033[0;33m"
-#define LOG_COLOR_BLUE "\033[0;34m"
-#define LOG_COLOR_PURPLE "\033[0;35m"
-#define LOG_COLOR_CYAN "\033[0;36m"
+#define LOG_COLOR_RED "\033[0;31m"
+#define LOG_COLOR_GREEN "\033[0;32m"
+#define LOG_COLOR_BROWN "\033[0;33m"
+#define LOG_COLOR_BLUE "\033[0;34m"
+#define LOG_COLOR_PURPLE "\033[0;35m"
+#define LOG_COLOR_CYAN "\033[0;36m"
#define LOG_COLOR_LIGHTBLUE "\033[0;37m"
#define LOG_COLOR_END "\033[0;m"
#define PRINT_INSTRUCT(format,args...) \
-do {\
- printf(LOG_COLOR_BLUE""format""LOG_COLOR_END"\n", ##args);\
-}while(0);
+ do {\
+ printf(LOG_COLOR_BLUE""format""LOG_COLOR_END"\n", ##args);\
+ }while(0);
#define PRINT_RESULT_FAIL(format,args...) \
-do {\
- printf(LOG_COLOR_RED""format""LOG_COLOR_END"\n", ##args);\
-}while(0);
+ do {\
+ printf(LOG_COLOR_RED""format""LOG_COLOR_END"\n", ##args);\
+ }while(0);
#define PRINT_RESULT_SUCCESS(format,args...) \
-do {\
- printf(LOG_COLOR_GREEN""format""LOG_COLOR_END"\n", ##args);\
-}while(0);
+ do {\
+ printf(LOG_COLOR_GREEN""format""LOG_COLOR_END"\n", ##args);\
+ }while(0);
#define PRINT_INFO(format,args...) \
-do {\
- printf(format"\n", ##args);\
-}while(0);
+ do {\
+ printf(format"\n", ##args);\
+ }while(0);
#define CHECK_RESULT(X)\
typedef struct
{
- char* testName;
- nfcTestStartFn_t* testFn;
- uint8_t testResult;
+ char *testName;
+ nfcTestStartFn_t *testFn;
+ uint8_t testResult;
} nfcTestType;
-#endif //__NFC_API_TEST_H__
\ No newline at end of file
+#endif //__NFC_API_TEST_H__
projects / platform / core / connectivity / nfc-manager-neard.git / commitdiff