#include "net_nfc_client_llcp.h"
#include "net_nfc_client_p2p.h"
#include "net_nfc_client_snep.h"
-#include "net_nfc_client_exchanger.h"
#include "net_nfc_client_handover.h"
#include "net_nfc_client_se.h"
#include "net_nfc_client_tag_felica.h"
+++ /dev/null
-/*
- * 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 __NET_NFC_CLIENT_EXCHANGER_H__
-#define __NET_NFC_CLIENT_EXCHANGER_H__
-
-
-#include "net_nfc_typedef.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-@addtogroup NET_NFC_MANAGER_EXCHANGE
-@{
-
-*/
-
-
-/**
- create net_nfc_exchagner raw type data handler with given values
-
- @param[out] ex_data exchangner handler
- @param[in] payload the data will be deliver (NDEF message)
-
- @return result of this function call
-
- @exception NET_NFC_ALLOC_FAIL memory allocation is failed
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illegal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_create_exchanger_data(
- net_nfc_exchanger_data_h *ex_data,
- data_h payload);
-
-
-/**
- this makes free exchagner data handler
-
- @param[in] ex_data exchagner handler
-
- @return result of this function call
-
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_free_exchanger_data (
- net_nfc_exchanger_data_h ex_data);
-
-
-net_nfc_error_e net_nfc_client_unset_exchanger_cb();
-
-
-net_nfc_error_e net_nfc_client_send_exchanger_data (
- net_nfc_exchanger_data_h ex_handle,
- net_nfc_target_handle_h target_handle,
- void* trans_param);
-
-/**
- request connection handover with discovered P2P device
-
- @param[in] target_handle target device handle
- @param[in] type specific alternative carrier type (if type is NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN, it will be selected available type of this target)
- @param[in] trans_param user data
-
- @return result of this function call
-
- @exception NET_NFC_ALLOC_FAIL memory allocation is failed
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_request_connection_handover(
- net_nfc_target_handle_h target_handle,
- net_nfc_conn_handover_carrier_type_e type);
-
-/**
- get alternative carrier type from connection handover information handle.
-
- @param[in] info_handle connection handover information handle
- @param[out] type alternative carrier type
-
- @return return the result of this operation
-
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_type(
- net_nfc_connection_handover_info_h info_handle,
- net_nfc_conn_handover_carrier_type_e *type);
-
-/**
- get alternative carrier dependant data from connection handover information handle.
- Bluetooth : target device address
- Wifi : target device ip address
-
- @param[in] info_handle connection handover information handle
- @param[out] data alternative carrier data
-
- @return return the result of this operation
-
- @exception NET_NFC_ALLOC_FAIL memory allocation is failed
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle,
- data_h *data);
-
-/**
- this makes free alternative carrier data handler
-
- @param[in] info_handle alternative carrier data handler
-
- @return result of this function call
-
- @exception NET_NFC_NULL_PARAMETER parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_free_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle);
-
-
-/**
-@}
-*/
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif //__NET_NFC_CLIENT_EXCHANGER_H__
net_nfc_llcp_socket_t client_socket, void *user_data);
net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config,
- net_nfc_client_llcp_config_completed callback,
- void *user_data);
+ 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);
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_h 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_h 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_h 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_h 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_h 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_h config, uint8_t option);
net_nfc_error_e net_nfc_client_llcp_free_config(
net_nfc_llcp_config_info_h config);
#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_h message, void *user_data);
typedef void (*net_nfc_client_ndef_write_completed) (net_nfc_error_e result,
void *user_data);
ndef_message_h *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);
+ ndef_message_h 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_target_handle_h 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);
+ data_h key, net_nfc_client_ndef_format_completed callback, void *user_data);
-net_nfc_error_e net_nfc_client_ndef_format_sync(
- net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_ndef_format_sync(net_nfc_target_handle_h handle,
data_h key);
/* TODO : move to internal header */
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_h p2p_data, void *user_data);
/* P2P client API's*/
-net_nfc_error_e net_nfc_client_p2p_send(net_nfc_exchanger_data_h exchg_data,
- net_nfc_target_handle_h handle,
- net_nfc_client_p2p_send_completed callback,
- void *cb_data);
+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_sync(
- net_nfc_exchanger_data_h exchg_data,
- net_nfc_target_handle_h handle);
+net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_h handle,
+ data_h data);
/* P2P client API's - used for registering callbacks*/
void net_nfc_client_p2p_set_data_received(
- net_nfc_client_p2p_data_received callback,
- void *user_data);
+ net_nfc_client_p2p_data_received callback, void *user_data);
void net_nfc_client_p2p_set_device_detached(
- net_nfc_client_p2p_device_detached callback,
- void *user_data);
+ net_nfc_client_p2p_device_detached callback, void *user_data);
void net_nfc_client_p2p_set_device_discovered(
- net_nfc_client_p2p_device_discovered callback,
- void *user_data);
+ net_nfc_client_p2p_device_discovered callback, void *user_data);
/* P2P client API's - used for unregistering callbacks*/
void net_nfc_client_p2p_unset_data_received(void);
#include <glib.h>
+typedef struct _NetNfcCallback
+{
+ void *callback;
+ void *user_data;
+}
+NetNfcCallback;
void net_nfc_client_gdbus_init(void);
+++ /dev/null
-/*
- * 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.
- */
-
-#include <pthread.h>
-
-#include "net_nfc_typedef_internal.h"
-#include "net_nfc_debug_internal.h"
-#include "net_nfc_util_internal.h"
-#include "net_nfc_data.h"
-#include "net_nfc_client_context.h"
-#include "net_nfc_client_p2p.h"
-#include "net_nfc_client_handover.h"
-#include "net_nfc_client_exchanger.h"
-
-static net_nfc_exchanger_cb gdbus_exch_cb = NULL;
-
-API net_nfc_error_e net_nfc_client_create_exchanger_data(
- net_nfc_exchanger_data_h *ex_data,
- data_h payload)
-{
- net_nfc_exchanger_data_s* tmp_ex_data = NULL;
-
- if (ex_data == NULL || payload == NULL)
- {
- return NET_NFC_NULL_PARAMETER;
- }
-
- _net_nfc_util_alloc_mem(
- tmp_ex_data,
- sizeof(net_nfc_exchanger_data_s));
-
- if (tmp_ex_data == NULL)
- {
- return NET_NFC_ALLOC_FAIL;
- }
-
- tmp_ex_data->type = NET_NFC_EXCHANGER_RAW;
-
- _net_nfc_util_alloc_mem(
- tmp_ex_data->binary_data.buffer,
- ((data_s *)payload)->length);
-
- if (tmp_ex_data->binary_data.buffer == NULL)
- {
- _net_nfc_util_free_mem(tmp_ex_data);
-
- return NET_NFC_ALLOC_FAIL;
- }
-
- memcpy(tmp_ex_data->binary_data.buffer,
- ((data_s *)payload)->buffer,
- ((data_s *)payload)->length);
-
- tmp_ex_data->binary_data.length = ((data_s *)payload)->length;
-
- *ex_data = (net_nfc_exchanger_data_h)tmp_ex_data;
-
- return NET_NFC_OK;
-}
-
-
-API net_nfc_error_e net_nfc_client_free_exchanger_data(
- net_nfc_exchanger_data_h ex_data)
-{
- if (ex_data == NULL)
- {
- return NET_NFC_NULL_PARAMETER;
- }
-
- if (((net_nfc_exchanger_data_s *)ex_data)->binary_data.buffer != NULL)
- {
- _net_nfc_util_free_mem(
- ((net_nfc_exchanger_data_s *)ex_data)->binary_data.buffer);
- }
-
- _net_nfc_util_free_mem(ex_data);
-
- return NET_NFC_OK;
-}
-
-API net_nfc_exchanger_cb net_nfc_client_get_exchanger_cb()
-{
- return gdbus_exch_cb;
-}
-
-API net_nfc_error_e net_nfc_client_unset_exchanger_cb()
-{
-
- if (gdbus_exch_cb == NULL)
- {
- return NET_NFC_NOT_REGISTERED;
- }
-
- gdbus_exch_cb = NULL;
-
- net_nfc_client_deinitialize();
-
- return NET_NFC_OK;
-}
-
-API net_nfc_error_e net_nfc_client_send_exchanger_data(
- net_nfc_exchanger_data_h ex_handle,
- net_nfc_target_handle_h target_handle,
- void* trans_param)
-{
- net_nfc_error_e ret;
- net_nfc_exchanger_data_s *ex_data = (net_nfc_exchanger_data_s *)ex_handle;
-
- DEBUG_CLIENT_MSG("send reqeust :: exchanger data = "
- "[%p] target_handle = [%p]", ex_handle, target_handle);
-
- /*Sync call is used because there is no callback provided*/
- ret = net_nfc_client_p2p_send_sync(ex_data,target_handle);
-
- return ret;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_request_connection_handover(
- net_nfc_target_handle_h target_handle,
- net_nfc_conn_handover_carrier_type_e type)
-{
- net_nfc_error_e ret = NET_NFC_UNKNOWN_ERROR;
- net_nfc_conn_handover_carrier_type_e carrier_type;
- data_h data = NULL;
-
- if (target_handle == NULL)
- {
- return NET_NFC_NULL_PARAMETER;
- }
-
- ret = net_nfc_client_p2p_connection_handover_sync(target_handle,
- type,
- &carrier_type,
- &data);
-
- return ret;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_type(
- net_nfc_connection_handover_info_h info_handle,
- net_nfc_conn_handover_carrier_type_e *type)
-{
- net_nfc_connection_handover_info_s *info = NULL;
-
- if (info_handle == NULL || type == NULL)
- return NET_NFC_NULL_PARAMETER;
-
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
- *type = info->type;
-
- return NET_NFC_OK;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle,
- data_h *data)
-{
- net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- net_nfc_connection_handover_info_s *info = NULL;
-
- if (info_handle == NULL || data == NULL)
- return NET_NFC_NULL_PARAMETER;
-
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
- result = net_nfc_create_data(data, info->data.buffer, info->data.length);
-
- return result;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_free_alternative_carrier_data(
- net_nfc_connection_handover_info_h info_handle)
-{
- net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- net_nfc_connection_handover_info_s *info = NULL;
-
- if (info_handle == NULL)
- return NET_NFC_NULL_PARAMETER;
-
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
- if (info->data.buffer != NULL)
- {
- _net_nfc_util_free_mem(info->data.buffer);
- }
-
- _net_nfc_util_free_mem(info);
-
- return result;
-}
#include "net_nfc_client_manager.h"
#include "net_nfc_client_handover.h"
-typedef struct _HandoverFuncData HandoverFuncData;
-
-struct _HandoverFuncData
-{
- gpointer handover_callback;
- gpointer handover_data;
-};
static NetNfcGDbusHandover *handover_proxy = NULL;
GAsyncResult *res,
gpointer user_data)
{
- HandoverFuncData *func_data;
- GVariant *data;
- GError *error = NULL;
+ NetNfcCallback *func_data = (NetNfcCallback *)user_data;
+ GVariant *data = NULL;
net_nfc_error_e result = NET_NFC_OK;
- net_nfc_exchanger_event_e event;
- net_nfc_conn_handover_carrier_type_e type;
+ net_nfc_conn_handover_carrier_type_e type =
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
+ GError *error = NULL;
data_s arg_data;
- net_nfc_p2p_connection_handover_completed_cb callback;
+ g_assert(user_data != NULL);
- if(net_nfc_gdbus_handover_call_request_finish (handover_proxy,
- (gint32 *)&event,
- (gint32 *)&type,
+ if (net_nfc_gdbus_handover_call_request_finish(handover_proxy,
+ (gint *)&result,
+ (gint *)&type,
&data,
res,
&error) == FALSE)
{
- result = NET_NFC_UNKNOWN_ERROR;
-
DEBUG_ERR_MSG("Can not finish"
" connection handover: %s", error->message);
g_error_free(error);
- return;
- }
- func_data = user_data;
- if(func_data == NULL)
- {
- DEBUG_ERR_MSG("can not get HandoverFuncData");
- return;
+ result = NET_NFC_IPC_FAIL;
}
- if(func_data->handover_callback == NULL)
+ if (func_data->callback != NULL)
{
- DEBUG_CLIENT_MSG("callback function is not avaiilable");
- g_free(func_data);
- return;
- }
-
- net_nfc_util_gdbus_variant_to_data_s(data, &arg_data);
+ net_nfc_p2p_connection_handover_completed_cb callback =
+ (net_nfc_p2p_connection_handover_completed_cb)func_data->callback;
- callback = (net_nfc_p2p_connection_handover_completed_cb)
- func_data->handover_callback;
+ net_nfc_util_gdbus_variant_to_data_s(data, &arg_data);
- callback(result,
- type,
- &arg_data,
- func_data->handover_data);
+ callback(result, type, &arg_data, func_data->user_data);
- net_nfc_util_free_data(&arg_data);
+ net_nfc_util_free_data(&arg_data);
+ }
g_free(func_data);
}
API net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
net_nfc_connection_handover_info_h info_handle)
{
- net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- net_nfc_connection_handover_info_s *info = NULL;
+ net_nfc_connection_handover_info_s *info =
+ (net_nfc_connection_handover_info_s *)info_handle;
if (info_handle == NULL)
return NET_NFC_NULL_PARAMETER;
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
if (info->data.buffer != NULL)
{
_net_nfc_util_free_mem(info->data.buffer);
_net_nfc_util_free_mem(info);
- return result;
+ return NET_NFC_OK;
}
net_nfc_connection_handover_info_h info_handle,
net_nfc_conn_handover_carrier_type_e *type)
{
- net_nfc_connection_handover_info_s *info = NULL;
+ net_nfc_connection_handover_info_s *info =
+ (net_nfc_connection_handover_info_s *)info_handle;
if (info_handle == NULL || type == NULL)
return NET_NFC_NULL_PARAMETER;
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
*type = info->type;
return NET_NFC_OK;
}
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_h info_handle, data_h *data)
{
- net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
- net_nfc_connection_handover_info_s *info = NULL;
+ net_nfc_connection_handover_info_s *info =
+ (net_nfc_connection_handover_info_s *)info_handle;
if (info_handle == NULL || data == NULL)
return NET_NFC_NULL_PARAMETER;
- info = (net_nfc_connection_handover_info_s *)info_handle;
-
- result = net_nfc_create_data(data, info->data.buffer, info->data.length);
-
- return result;
+ return net_nfc_create_data(data, info->data.buffer, info->data.length);
}
net_nfc_p2p_connection_handover_completed_cb callback,
void *cb_data)
{
+ NetNfcCallback *funcdata;
- HandoverFuncData *funcdata = NULL;
- net_nfc_target_handle_s *tag_handle = (net_nfc_target_handle_s *)handle;
-
- if(handover_proxy == NULL)
+ if (handover_proxy == NULL)
{
DEBUG_ERR_MSG("Can not get handover Proxy");
- return NET_NFC_UNKNOWN_ERROR;
+
+ return NET_NFC_NOT_INITIALIZED;
}
/* prevent executing daemon when nfc is off */
return NET_NFC_INVALID_STATE;
}
- funcdata = g_new0(HandoverFuncData, 1);
- if (funcdata == NULL)
- return NET_NFC_UNKNOWN_ERROR;
+ funcdata = g_try_new0(NetNfcCallback, 1);
+ if (funcdata == NULL) {
+ return NET_NFC_ALLOC_FAIL;
+ }
- funcdata->handover_callback = (gpointer)callback;
- funcdata->handover_data = cb_data;
+ funcdata->callback = (gpointer)callback;
+ funcdata->user_data = cb_data;
net_nfc_gdbus_handover_call_request(handover_proxy,
- GPOINTER_TO_UINT(tag_handle),
+ GPOINTER_TO_UINT(handle),
arg_type,
net_nfc_client_gdbus_get_privilege(),
NULL,
net_nfc_conn_handover_carrier_type_e *out_carrier,
data_h *out_ac_data)
{
-
- net_nfc_target_handle_s *tag_handle = (net_nfc_target_handle_s *)handle;
+ GVariant *out_data = NULL;
+ net_nfc_error_e out_result = NET_NFC_OK;
+ net_nfc_conn_handover_carrier_type_e out_type =
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
GError *error = NULL;
- GVariant *out_data;
- net_nfc_exchanger_event_e out_event;
- net_nfc_conn_handover_carrier_type_e out_type;
- if(handover_proxy == NULL)
+ if (handover_proxy == NULL)
{
DEBUG_ERR_MSG("Can not get handover Proxy");
- return NET_NFC_UNKNOWN_ERROR;
+
+ return NET_NFC_NOT_INITIALIZED;
}
/* prevent executing daemon when nfc is off */
return NET_NFC_INVALID_STATE;
}
- if(net_nfc_gdbus_handover_call_request_sync(handover_proxy,
- GPOINTER_TO_UINT(tag_handle),
+ if (net_nfc_gdbus_handover_call_request_sync(handover_proxy,
+ GPOINTER_TO_UINT(handle),
arg_type,
net_nfc_client_gdbus_get_privilege(),
- (gint32 *)&out_event,
+ (gint32 *)&out_result,
(gint32 *)&out_type,
&out_data,
NULL,
- &error) == FALSE)
- {
+ &error) == TRUE) {
+ if (out_carrier) {
+ *out_carrier = out_type;
+ }
+
+ if (out_ac_data) {
+ *out_ac_data = net_nfc_util_gdbus_variant_to_data(out_data);
+ }
+ } else {
DEBUG_ERR_MSG("handover (sync call) failed: %s",error->message);
g_error_free(error);
- return NET_NFC_UNKNOWN_ERROR;
- }
-
- if (out_carrier)
- {
- *out_carrier = out_type;
- }
- if (out_ac_data)
- {
- *out_ac_data = net_nfc_util_gdbus_variant_to_data(out_data);
+ out_result = NET_NFC_IPC_FAIL;
}
- return NET_NFC_OK;
+ return out_result;
}
-API net_nfc_error_e net_nfc_client_handover_init(void)
+net_nfc_error_e net_nfc_client_handover_init(void)
{
GError *error = NULL;
NULL,
&error);
- if(handover_proxy == NULL)
+ if (handover_proxy == NULL)
{
DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
g_error_free(error);
return NET_NFC_OK;
}
-API void net_nfc_client_handover_deinit(void)
+
+void net_nfc_client_handover_deinit(void)
{
- if(handover_proxy)
+ if (handover_proxy)
{
g_object_unref(handover_proxy);
handover_proxy = NULL;
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_llcp_config_sync
-(net_nfc_llcp_config_info_h config)
+API net_nfc_error_e net_nfc_client_llcp_config_sync(
+ net_nfc_llcp_config_info_h config)
{
GVariant *variant = NULL;
GError *error = NULL;
NULL,
&error) == FALSE)
{
- DEBUG_ERR_MSG("can not config: %s",
- error->message);
+ DEBUG_ERR_MSG("can not config: %s", error->message);
g_error_free(error);
return NET_NFC_UNKNOWN_ERROR;
}
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_llcp_get_config
-(net_nfc_llcp_config_info_h *config)
+API net_nfc_error_e net_nfc_client_llcp_get_config(
+ net_nfc_llcp_config_info_h *config)
{
if (config == NULL)
return NET_NFC_NULL_PARAMETER;
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
const char *service_name,
sap_t sap,
net_nfc_client_llcp_listen_completed callback,
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
const char *service_name,
sap_t sap,
net_nfc_llcp_socket_t *out_socket)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
const char *service_name,
net_nfc_client_llcp_connect_completed callback,
void *user_data)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
+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)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
+API 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)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
+API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
net_nfc_llcp_socket_t socket,
sap_t sap,
net_nfc_llcp_socket_t *out_socket)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
+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)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
data_h data,
net_nfc_llcp_socket_t *out_socket)
{
}
- API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
sap_t sap,
data_h data,
net_nfc_client_llcp_send_to_completed callback,
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
sap_t sap,
data_h data,
net_nfc_llcp_socket_t *out_socket)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
size_t request_length,
net_nfc_client_llcp_receive_completed callback,
void *user_data)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
+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)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
size_t request_length,
net_nfc_client_llcp_receive_from_completed callback,
void *user_data)
return NET_NFC_OK;
}
-API 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)
+API 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)
{
GVariant *variant = NULL;
GError *error = NULL;
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
net_nfc_client_llcp_close_completed callback,
void *user_data)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket,
net_nfc_llcp_socket_t *out_socket)
{
GError *error = NULL;
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
net_nfc_client_llcp_disconnect_completed callback,
void *user_data)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
+API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
net_nfc_llcp_socket_t socket,
net_nfc_llcp_socket_t *out_socket)
{
}
- API net_nfc_error_e net_nfc_client_llcp_get_local_config(
+API net_nfc_error_e net_nfc_client_llcp_get_local_config(
net_nfc_llcp_config_info_h *config)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
*config = (net_nfc_llcp_config_info_h)&llcp_config;
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
+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)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
+API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
net_nfc_llcp_socket_option_h *option,
uint16_t miu,
uint8_t rw,
}
}
- API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
+API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
net_nfc_llcp_socket_option_h *option)
{
return net_nfc_client_llcp_create_socket_option(
NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
}
- API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
+API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
net_nfc_llcp_socket_option_h option,
uint16_t *miu)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
+API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
net_nfc_llcp_socket_option_h option,
uint16_t miu)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
+API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
net_nfc_llcp_socket_option_h option,
uint8_t *rw)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
+API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
net_nfc_llcp_socket_option_h option,
uint8_t rw)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
+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)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
+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)
{
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
+API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
net_nfc_llcp_socket_option_h option)
{
if (option == NULL)
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_create_config(
+API net_nfc_error_e net_nfc_client_llcp_create_config(
net_nfc_llcp_config_info_h *config,
uint16_t miu,
uint16_t wks,
uint8_t lto,
uint8_t option)
{
+ net_nfc_llcp_config_info_s *tmp_config;
+
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
- net_nfc_llcp_config_info_s **tmp_config =
- (net_nfc_llcp_config_info_s **)config;
+ _net_nfc_util_alloc_mem(tmp_config, sizeof(net_nfc_llcp_config_info_s));
- _net_nfc_util_alloc_mem(*tmp_config,
- sizeof(net_nfc_llcp_config_info_s));
-
- if (*tmp_config == NULL)
+ if (tmp_config == NULL)
return NET_NFC_ALLOC_FAIL;
- (*tmp_config)->miu = miu;
- (*tmp_config)->wks = wks;
- (*tmp_config)->lto = lto;
- (*tmp_config)->option = option;
+ tmp_config->miu = miu;
+ tmp_config->wks = wks;
+ tmp_config->lto = lto;
+ tmp_config->option = option;
+
+ *config = (net_nfc_llcp_config_info_h)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)
+API net_nfc_error_e net_nfc_client_llcp_create_config_default(
+ net_nfc_llcp_config_info_h *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)
+API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
+ net_nfc_llcp_config_info_h config, uint16_t *miu)
{
if (config == NULL || miu == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
+ net_nfc_llcp_config_info_h config, uint16_t *wks)
{
if (config == NULL || wks == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
+ net_nfc_llcp_config_info_h config, uint8_t *lto)
{
if (config == NULL || lto == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_get_config_option(
+ net_nfc_llcp_config_info_h config, uint8_t *option)
{
if (config == NULL || option == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
+ net_nfc_llcp_config_info_h config, uint16_t miu)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
if (miu < 128 || miu > 1152)
- {
return NET_NFC_OUT_OF_BOUND;
- }
net_nfc_llcp_config_info_s * tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
+ net_nfc_llcp_config_info_h config, uint16_t wks)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
+ net_nfc_llcp_config_info_h config, uint8_t lto)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s *tmp_config =
(net_nfc_llcp_config_info_s *)config;
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)
+API net_nfc_error_e net_nfc_client_llcp_set_config_option(
+ net_nfc_llcp_config_info_h config, uint8_t option)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
net_nfc_llcp_config_info_s * tmp_config =
(net_nfc_llcp_config_info_s *)config;
return NET_NFC_OK;
}
- API net_nfc_error_e net_nfc_client_llcp_free_config(net_nfc_llcp_config_info_h config)
+API net_nfc_error_e net_nfc_client_llcp_free_config(
+ net_nfc_llcp_config_info_h config)
{
if (config == NULL)
- {
return NET_NFC_NULL_PARAMETER;
- }
_net_nfc_util_free_mem(config);
return NET_NFC_OK;
return NET_NFC_UNKNOWN_ERROR;
}
- g_signal_connect(llcp_proxy, "error",
- G_CALLBACK(llcp_error), NULL);
+ g_signal_connect(llcp_proxy, "error", G_CALLBACK(llcp_error), NULL);
return NET_NFC_OK;
}
#include "net_nfc_client_manager.h"
#include "net_nfc_client_p2p.h"
-typedef struct _P2pFuncData P2pFuncData;
-
-struct _P2pFuncData
-{
- gpointer p2p_send_callback;
- gpointer p2p_send_data;
-};
-
typedef struct _P2p_SignalHandler P2pSignalHandler;
};
static NetNfcGDbusP2p *p2p_proxy = NULL;
-static P2pSignalHandler *p2p_signal_handler = NULL;
+static P2pSignalHandler p2p_signal_handler;
static void p2p_device_detached(GObject *source_object,
gpointer user_data);
/*llcp client function to set/unset the current target id needs to be implemented*/
/*net_nfc_client_llcp_current_target_id(NULL);*/
- if(p2p_signal_handler == NULL)
- return;
-
- if(p2p_signal_handler->p2p_device_detached_cb)
+ if (p2p_signal_handler.p2p_device_detached_cb)
{
- p2p_signal_handler->p2p_device_detached_cb(
- p2p_signal_handler->p2p_device_detached_data);
+ p2p_signal_handler.p2p_device_detached_cb(
+ p2p_signal_handler.p2p_device_detached_data);
}
/*llcp client function to close all socket needs to be implemented*/
/*net_nfc_client_llcp_close_all_socket();*/
}
-static void p2p_device_discovered(GObject *source_object,
- guint arg_handle,
+static void p2p_device_discovered(GObject *source_object, guint arg_handle,
gpointer user_data)
{
net_nfc_target_handle_s *handle_info = NULL;
handle_info = GUINT_TO_POINTER(arg_handle);
- if(p2p_signal_handler == NULL)
- return;
-
- if(p2p_signal_handler->p2p_device_discovered_cb)
+ if (p2p_signal_handler.p2p_device_discovered_cb)
{
- p2p_signal_handler->p2p_device_discovered_cb(handle_info,
- p2p_signal_handler->p2p_device_discovered_data);
+ p2p_signal_handler.p2p_device_discovered_cb(handle_info,
+ p2p_signal_handler.p2p_device_discovered_data);
}
}
-static void p2p_device_data_received(GObject *source_object,
- GVariant *arg_data,
+static void p2p_device_data_received(GObject *source_object, GVariant *arg_data,
gpointer user_data)
{
INFO_MSG(">>> SIGNAL arrived");
- if (p2p_signal_handler == NULL)
- return;
-
- if (p2p_signal_handler->p2p_data_received_cb)
+ if (p2p_signal_handler.p2p_data_received_cb)
{
- data_s p2p_data;
+ data_s p2p_data = { NULL, };
net_nfc_util_gdbus_variant_to_data_s(arg_data, &p2p_data);
- p2p_signal_handler->p2p_data_received_cb(&p2p_data,
- p2p_signal_handler->p2p_data_received_data);
+ p2p_signal_handler.p2p_data_received_cb(&p2p_data,
+ p2p_signal_handler.p2p_data_received_data);
net_nfc_util_free_data(&p2p_data);
}
}
-static void p2p_call_send(GObject *source_object,
- GAsyncResult *res,
+static void p2p_call_send(GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
- P2pFuncData *func_data;
-
- net_nfc_error_e out_result = NET_NFC_OK;
+ NetNfcCallback *func_data = (NetNfcCallback *)user_data;
+ net_nfc_error_e out_result;
GError *error = NULL;
- net_nfc_client_p2p_send_completed callback;
+ g_assert(user_data != NULL);
if (net_nfc_gdbus_p2p_call_send_finish(
NET_NFC_GDBUS_P2P(source_object),
g_error_free(error);
}
- func_data = user_data;
- if (func_data == NULL)
+ if (func_data->callback != NULL)
{
- DEBUG_ERR_MSG("can not get P2pFuncData");
- return;
- }
+ net_nfc_client_p2p_send_completed callback =
+ (net_nfc_client_p2p_send_completed)func_data->callback;
- if (func_data->p2p_send_callback == NULL)
- {
- DEBUG_CLIENT_MSG("callback function is not avaiilable");
- g_free(func_data);
- return;
+ callback(out_result, func_data->user_data);
}
- callback = (net_nfc_client_p2p_send_completed)
- func_data->p2p_send_callback;
- callback(out_result, func_data->p2p_send_data);
-
g_free(func_data);
}
-API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_exchanger_data_h exchg_data,
- net_nfc_target_handle_h handle,
- net_nfc_client_p2p_send_completed callback,
- void *cb_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;
- GVariant *arg_data = NULL;
- P2pFuncData *func_data = NULL;
- net_nfc_exchanger_data_s *exch_data;
-
- if(p2p_proxy == NULL)
+ if (p2p_proxy == NULL)
{
DEBUG_ERR_MSG("Can not get P2pProxy");
- return NET_NFC_UNKNOWN_ERROR;
+
+ return NET_NFC_NOT_INITIALIZED;
}
/* prevent executing daemon when nfc is off */
return NET_NFC_INVALID_STATE;
}
- func_data = g_new0(P2pFuncData, 1);
-
- func_data->p2p_send_callback = (gpointer)callback;
- func_data->p2p_send_data = cb_data;
+ func_data = g_try_new0(NetNfcCallback, 1);
+ if (func_data == NULL) {
+ return NET_NFC_ALLOC_FAIL;
+ }
- exch_data = (net_nfc_exchanger_data_s *)exchg_data;
+ func_data->callback = (gpointer)callback;
+ func_data->user_data = user_data;
- arg_data = net_nfc_util_gdbus_data_to_variant(&exch_data->binary_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant(data);
net_nfc_gdbus_p2p_call_send(p2p_proxy,
- exch_data->type,
- arg_data,
- GPOINTER_TO_UINT(handle),
- net_nfc_client_gdbus_get_privilege(),
- NULL,
- p2p_call_send,
- func_data);
+ 0 /* FIXME */,
+ arg_data,
+ GPOINTER_TO_UINT(handle),
+ net_nfc_client_gdbus_get_privilege(),
+ NULL,
+ p2p_call_send,
+ func_data);
return NET_NFC_OK;
}
-API net_nfc_error_e net_nfc_client_p2p_send_sync(
- net_nfc_exchanger_data_h exchg_data,
- net_nfc_target_handle_h handle)
+API net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_s *handle,
+ data_s *data)
{
- GVariant *arg_data = NULL;
+ GVariant *arg_data;
GError *error = NULL;
- net_nfc_exchanger_data_s *exch_data;
- net_nfc_error_e out_result = NET_NFC_OK;
+ net_nfc_error_e out_result;
if (p2p_proxy == NULL)
{
DEBUG_ERR_MSG("Can not get P2pProxy");
- return NET_NFC_UNKNOWN_ERROR;
+ return NET_NFC_NOT_INITIALIZED;
}
/* prevent executing daemon when nfc is off */
return NET_NFC_INVALID_STATE;
}
- exch_data = (net_nfc_exchanger_data_s *)exchg_data;
-
- arg_data = net_nfc_util_gdbus_data_to_variant(&exch_data->binary_data);
+ arg_data = net_nfc_util_gdbus_data_to_variant(data);
if (net_nfc_gdbus_p2p_call_send_sync(p2p_proxy,
- exch_data->type,
- arg_data,
- GPOINTER_TO_UINT(handle),
- net_nfc_client_gdbus_get_privilege(),
- (gint *)&out_result,
- NULL,
- &error) == FALSE)
+ 0 /* FIXME */,
+ arg_data,
+ GPOINTER_TO_UINT(handle),
+ net_nfc_client_gdbus_get_privilege(),
+ (gint *)&out_result,
+ NULL,
+ &error) == FALSE)
{
DEBUG_ERR_MSG("p2p send (sync call) failed: %s",
error->message);
g_error_free(error);
- return NET_NFC_UNKNOWN_ERROR;
+ out_result = NET_NFC_IPC_FAIL;
}
return out_result;
API void net_nfc_client_p2p_set_device_discovered(
- net_nfc_client_p2p_device_discovered callback,
- void *user_data)
+ net_nfc_client_p2p_device_discovered callback, void *user_data)
{
- if(p2p_signal_handler == NULL)
- {
- p2p_signal_handler = g_new0(P2pSignalHandler, 1);
- }
-
- p2p_signal_handler->p2p_device_discovered_cb = callback;
- p2p_signal_handler->p2p_device_discovered_data = user_data;
+ p2p_signal_handler.p2p_device_discovered_cb = callback;
+ p2p_signal_handler.p2p_device_discovered_data = user_data;
}
API void net_nfc_client_p2p_set_device_detached(
- net_nfc_client_p2p_device_detached callback,
- void *user_data)
+ net_nfc_client_p2p_device_detached callback, void *user_data)
{
- if(p2p_signal_handler == NULL)
- {
- p2p_signal_handler = g_new0(P2pSignalHandler, 1);
- }
-
- p2p_signal_handler->p2p_device_detached_cb = callback;
- p2p_signal_handler->p2p_device_detached_data = user_data;
+ p2p_signal_handler.p2p_device_detached_cb = callback;
+ p2p_signal_handler.p2p_device_detached_data = user_data;
}
API void net_nfc_client_p2p_set_data_received(
- net_nfc_client_p2p_data_received callback,
- void *user_data)
+ net_nfc_client_p2p_data_received callback, void *user_data)
{
- if(p2p_signal_handler == NULL)
- {
- p2p_signal_handler = g_new0(P2pSignalHandler, 1);
- }
-
- p2p_signal_handler->p2p_data_received_cb = callback;
- p2p_signal_handler->p2p_data_received_data = user_data;
+ p2p_signal_handler.p2p_data_received_cb = callback;
+ p2p_signal_handler.p2p_data_received_data = user_data;
}
API void net_nfc_client_p2p_unset_device_discovered(void)
{
- if(p2p_signal_handler == NULL)
- {
- DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
- return;
- }
-
- else
- {
- p2p_signal_handler->p2p_device_discovered_cb = NULL;
- p2p_signal_handler->p2p_device_discovered_data = NULL;
- g_free(p2p_signal_handler);
- p2p_signal_handler = NULL;
- }
+ p2p_signal_handler.p2p_device_discovered_cb = NULL;
+ p2p_signal_handler.p2p_device_discovered_data = NULL;
}
API void net_nfc_client_p2p_unset_device_detached(void)
{
- if(p2p_signal_handler == NULL)
- {
- DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
- return;
- }
-
- else
- {
- p2p_signal_handler->p2p_device_detached_cb = NULL;
- p2p_signal_handler->p2p_device_detached_data = NULL;
- }
+ p2p_signal_handler.p2p_device_detached_cb = NULL;
+ p2p_signal_handler.p2p_device_detached_data = NULL;
}
API void net_nfc_client_p2p_unset_data_received(void)
{
- if(p2p_signal_handler == NULL)
- {
- DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
- return;
- }
-
- else
- {
- p2p_signal_handler->p2p_data_received_cb = NULL;
- p2p_signal_handler->p2p_data_received_data = NULL;
- }
+ p2p_signal_handler.p2p_data_received_cb = NULL;
+ p2p_signal_handler.p2p_data_received_data = NULL;
}
net_nfc_error_e net_nfc_client_p2p_init(void)
void net_nfc_client_p2p_deinit(void)
{
- if(p2p_proxy)
+ if (p2p_proxy)
{
g_object_unref(p2p_proxy);
p2p_proxy = NULL;
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
-
-#include "net_nfc_server_common.h"
-#include "net_nfc_server_process_handover.h"
-#include "net_nfc_server_handover.h"
#include "net_nfc_debug_internal.h"
-#include "net_nfc_server_controller.h"
#include "net_nfc_util_gdbus_internal.h"
+#include "net_nfc_server_controller.h"
+#include "net_nfc_server_common.h"
#include "net_nfc_server_context.h"
+#include "net_nfc_server_handover.h"
+#include "net_nfc_server_process_handover.h"
static NetNfcGDbusHandover *handover_skeleton = NULL;
static void handover_request_thread_func(gpointer user_data)
{
- HandoverRequestData *handover_data;
- net_nfc_target_handle_s *handle;
- net_nfc_error_e error = NET_NFC_OK;
-
- handover_data = (HandoverRequestData *)user_data;
-
- if (handover_data == NULL)
- {
- DEBUG_ERR_MSG("cannot send Handover data");
-
- return;
- }
-
- if (handover_data->handoverobj == NULL)
- {
- DEBUG_ERR_MSG("can not get Handover object");
-
- if (handover_data->invocation)
- {
- g_dbus_method_invocation_return_dbus_error(
- handover_data->invocation,
- "org.tizen.NetNfcService.Handover.DataError",
- "Handover invocation is NULL");
+ HandoverRequestData *handover_data = (HandoverRequestData *)user_data;
+ net_nfc_error_e result;
- g_object_unref(handover_data->invocation);
- }
+ g_assert(handover_data != NULL);
+ g_assert(handover_data->handoverobj != NULL);
+ g_assert(handover_data->invocation != NULL);
- g_free(handover_data);
-
- return;
- }
-
- handle = GUINT_TO_POINTER(handover_data->handle);
-
- if ((error = net_nfc_server_handover_default_client_start(
- handle,
- (void *)handover_data)) != NET_NFC_OK)
+ result = net_nfc_server_handover_default_client_start(
+ GUINT_TO_POINTER(handover_data->handle),
+ (void *)handover_data);
+ if (result != NET_NFC_OK)
{
- if (handover_data->invocation)
- {
- g_dbus_method_invocation_return_dbus_error(
- handover_data->invocation,
- "org.tizen.NetNfcService.Handover.SendError",
- "handover operation unsuccessfull");
-
- g_object_unref(handover_data->invocation);
- }
-
+ net_nfc_gdbus_handover_complete_request(
+ handover_data->handoverobj,
+ handover_data->invocation,
+ result,
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+ net_nfc_util_gdbus_buffer_to_variant(NULL, 0));
+
+ g_object_unref(handover_data->invocation);
g_object_unref(handover_data->handoverobj);
+
g_free(handover_data);
}
}
gpointer user_data)
{
HandoverRequestData *data;
+ gboolean result;
INFO_MSG(">>> REQUEST from [%s]",
g_dbus_method_invocation_get_sender(invocation));
"rw") == false) {
DEBUG_ERR_MSG("permission denied, and finished request");
- return TRUE;
+ return FALSE;
}
- data = g_new0(HandoverRequestData,1);
+ data = g_try_new0(HandoverRequestData,1);
if(data == NULL)
{
DEBUG_ERR_MSG("Memory allocation failed");
}
data->handoverobj = g_object_ref(hdover);
+ data->invocation = g_object_ref(invocation);
data->handle = arg_handle;
data->type = arg_type;
- data->invocation = g_object_ref(invocation);
- if (net_nfc_server_controller_async_queue_push(
- handover_request_thread_func, data) == FALSE)
+ result = net_nfc_server_controller_async_queue_push(
+ handover_request_thread_func, data);
+ if (result == FALSE)
{
g_dbus_method_invocation_return_dbus_error(invocation,
"org.tizen.NetNfcService.Handover.ThreadError",
"can not push to controller thread");
- g_object_unref(data->handoverobj);
g_object_unref(data->invocation);
- g_free(data);
+ g_object_unref(data->handoverobj);
- return FALSE;
+ g_free(data);
}
- return TRUE;
+ return result;
}
gboolean net_nfc_server_handover_init(GDBusConnection *connection)
&error) == FALSE)
{
g_error_free(error);
+
g_object_unref(handover_skeleton);
handover_skeleton = NULL;
-static void _net_nfc_server_handover_send_response(void *user_param,
- data_h ac_data,
- net_nfc_error_e result);
+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,
+ void *user_param);
static void _net_nfc_server_handover_client_process(
net_nfc_handover_context_t *context);
////////////////////////////////////////////////////////////////////////////
static void _net_nfc_server_handover_send_response(
- void *user_param,
- data_h ac_data,
- net_nfc_error_e result)
+ net_nfc_error_e result,
+ net_nfc_conn_handover_carrier_type_e carrier,
+ data_s *ac_data,
+ void *user_param)
{
- HandoverRequestData *handover_data = NULL;
- guint32 resp_event;
- guint32 resp_type;
- GVariant* data = NULL;
-
- handover_data = (HandoverRequestData*)user_param;
-
- data = net_nfc_util_gdbus_data_to_variant(ac_data);
+ HandoverRequestData *handover_data = (HandoverRequestData *)user_param;
- resp_type = NET_NFC_MESSAGE_CONNECTION_HANDOVER;
-
- if (result == NET_NFC_OK)
- resp_event = NET_NFC_EXCHANGER_TRANSFER_COMPLETED;
- else
- resp_event = NET_NFC_EXCHANGER_TRANSFER_FAILED;
-
- if (handover_data->invocation)
- {
- net_nfc_gdbus_handover_complete_request(
- handover_data->handoverobj,
- handover_data->invocation,
- resp_event,
- resp_type,
- data);
+ g_assert(handover_data != NULL);
+ g_assert(handover_data->invocation != NULL);
+ g_assert(handover_data->handoverobj != NULL);
- g_object_unref(handover_data->invocation);
- }
+ net_nfc_gdbus_handover_complete_request(
+ handover_data->handoverobj,
+ handover_data->invocation,
+ result,
+ carrier,
+ net_nfc_util_gdbus_data_to_variant(ac_data));
if (handover_data->data)
{
g_free(handover_data->data);
}
+ g_object_unref(handover_data->invocation);
g_object_unref(handover_data->handoverobj);
g_free(handover_data);
/* complete and invoke callback */
_net_nfc_server_handover_send_response(
- context->user_param,
+ context->result,
+ context->type,
&context->data,
- context->result);
+ context->user_param);
net_nfc_util_free_data(&context->data);
net_nfc_util_free_record(context->record);
DEBUG_ERR_MSG("NET_NFC_STATE_ERROR");
_net_nfc_server_handover_send_response(
- context->user_param,
+ context->result,
+ context->type,
NULL,
- context->result);
+ context->user_param);
break;
}
}
if (false)
{
- _net_nfc_server_handover_send_response(user_param, NULL, result);
+ _net_nfc_server_handover_send_response(
+ result,
+ NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+ NULL,
+ user_param);
}
net_nfc_controller_llcp_socket_close(socket, &result);
#include "net_nfc_test_jewel.h"
#include "net_nfc_test_tag_mifare.h"
#include "net_nfc_test_tag_felica.h"
-#include "net_nfc_test_exchanger.h"
#include "net_nfc_test_se.h"
#include "net_nfc_test_sys_handler.h"
},
{
- "Exchanger",
- "HandleData",
- net_nfc_test_handle_exchanger_data,
- net_nfc_test_handle_exchanger_data,
- "Create/Free exchanger data"
- },
-
- {
- "Exchanger",
- "SendData",
- net_nfc_test_send_exchanger_data,
- net_nfc_test_send_exchanger_data,
- "Send Exchanger Data"
- },
-
- {
- "Exchanger",
- "ConnectionHandover",
- net_nfc_test_exchanger_request_connection_handover,
- net_nfc_test_exchanger_request_connection_handover,
- "Request Connection Hnadover"
- },
-
- {
- "Exchanger",
- "GetCarrierData",
- net_nfc_test_exchanger_get_alternative_carrier_data,
- net_nfc_test_exchanger_get_alternative_carrier_data,
- "Get alternative carrier data"
- },
-
- {
- "Exchanger",
- "GetCarrierType",
- net_nfc_test_exchanger_get_alternative_carrier_type,
- net_nfc_test_exchanger_get_alternative_carrier_type,
- "Get Alternative carrier type"
- },
-
- {
"llcp",
"CreateSocket",
net_nfc_test_llcp_create_socket,
+++ /dev/null
-/*
- * 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.
- */
-
-#include "net_nfc_test_p2p.h"
-#include "net_nfc_target_info.h"
-#include "net_nfc_client_exchanger.h"
-#include "net_nfc_test_exchanger.h"
-#include "net_nfc_ndef_message.h"
-#include "net_nfc_test_util.h"
-#include "net_nfc_ndef_record.h"
-#include "net_nfc_typedef_internal.h"
-
-
-
-static void run_next_callback(gpointer user_data);
-
-static net_nfc_exchanger_data_h _net_nfc_test_create_exchgr_data();
-
-
-static void run_next_callback(gpointer user_data)
-{
- if (user_data)
- {
- GCallback callback;
-
- callback = (GCallback)(user_data);
- callback();
- }
-}
-
-static net_nfc_exchanger_data_h _net_nfc_test_create_exchgr_data()
-{
- net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- data_h rawdata = NULL;
- ndef_record_h record = NULL;
- net_nfc_exchanger_data_h exch_data = 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_append_record_to_ndef_message (msg ,record);
- net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
-
- if((result = net_nfc_client_create_exchanger_data(&exch_data, rawdata)) != NET_NFC_OK)
- {
- net_nfc_free_data(rawdata);
- g_printerr(" Exchanger data creation failed \n");
- return NULL;
- }
- net_nfc_free_data(rawdata);
- return exch_data;
-}
-
-void net_nfc_test_handle_exchanger_data(gpointer data, gpointer user_data)
-{
- net_nfc_error_e result = NET_NFC_OK;
- ndef_message_h msg = NULL;
- data_h rawdata = NULL;
- ndef_record_h record = NULL;
- net_nfc_exchanger_data_h exch_data = 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_append_record_to_ndef_message (msg ,record);
- net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
-
- if((result = net_nfc_client_create_exchanger_data(&exch_data, rawdata)) != NET_NFC_OK)
- {
- net_nfc_free_data(rawdata);
- g_printerr(" Exchanger data creation failed : %d\n", result);
- return;
- }
- if((result = net_nfc_client_free_exchanger_data(exch_data)) != NET_NFC_OK)
- {
- g_printerr(" Exchanger data free failed : %d\n", result);
- return;
- }
-
- net_nfc_free_data(rawdata);
-
- g_print("Exchanger data created and freed successfully\n");
- return;
-}
-
-void net_nfc_test_send_exchanger_data(gpointer data, gpointer user_data)
-{
- net_nfc_error_e result = NET_NFC_OK;
- net_nfc_target_handle_h handle = NULL;
- net_nfc_exchanger_data_h exch_data = NULL;
-
- exch_data = _net_nfc_test_create_exchgr_data();
- handle = net_nfc_test_device_get_target_handle();
-
- result = net_nfc_client_send_exchanger_data(exch_data,
- handle,
- user_data);
- g_print("Send exchanger result : %d\n", result);
- run_next_callback(user_data);
-}
-
-void net_nfc_test_exchanger_request_connection_handover(gpointer data, gpointer user_data)
-{
- net_nfc_error_e result = NET_NFC_OK;
- net_nfc_conn_handover_carrier_type_e type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
- net_nfc_target_handle_h handle = NULL;
-
- handle = net_nfc_test_device_get_target_handle();
- result = net_nfc_client_exchanger_request_connection_handover(handle, type);
-
- g_print(" Exchanger request connection handover : %d\n", result);
- run_next_callback(user_data);
-}
-
-void net_nfc_test_exchanger_get_alternative_carrier_type(gpointer data, gpointer user_data)
-{
- net_nfc_error_e result = NET_NFC_OK;
- /*Handover info needs to check-.As of now passing NULL*/
- net_nfc_connection_handover_info_s info;
- info.type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
-
- net_nfc_conn_handover_carrier_type_e type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
-
- result = net_nfc_client_exchanger_get_alternative_carrier_type(&info, &type);
- g_print(" Exchanger alternative carrier type and result : %d \n %d",type, result);
-}
-
-void net_nfc_test_exchanger_get_alternative_carrier_data(gpointer data,
- gpointer user_data)
-{
- net_nfc_error_e result = NET_NFC_OK;
- /*Handover info needs to check-.As of now passing NULL*/
- net_nfc_connection_handover_info_s info;
- uint8_t *carrier_data = "Wifi";
- data_h data_info = NULL;
-
- data_info = calloc(1,sizeof(data_h));
- result = net_nfc_set_data(data,carrier_data,4);
-
- result = net_nfc_client_exchanger_get_alternative_carrier_data(&info, &data_info);
- g_print(" Exchanger alternative carrier result : %d \n",result);
- print_received_data(data_info);
-}
-
+++ /dev/null
-/*
-* 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 __NET_NFC_TEST_EXCHANGER_H__
-#define __NET_NFC_TEST_EXCHANGER_H__
-
-
-#include <glib.h>
-#include "net_nfc_typedef.h"
-
-
-void net_nfc_test_handle_exchanger_data(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_send_exchanger_data(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_exchanger_request_connection_handover(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_exchanger_get_alternative_carrier_type(gpointer data,
- gpointer user_data);
-
-void net_nfc_test_exchanger_get_alternative_carrier_data(gpointer data,
- gpointer user_data);
-
-#endif //__NET_NFC_TEST_EXCHANGER_H__
*/
#include "net_nfc_client_p2p.h"
-#include "net_nfc_client_exchanger.h"
#include "net_nfc_test_p2p.h"
#include "net_nfc_test_util.h"
#include "net_nfc_target_info.h"
static net_nfc_target_handle_h 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_send(net_nfc_error_e result, void *user_data);
static void p2p_device_discovered(net_nfc_target_handle_h 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 run_next_callback(gpointer user_data)
GCallback callback;
callback = (GCallback)(user_data);
-
callback();
}
}
-static void p2p_send(net_nfc_error_e result,
- void *user_data)
+static void p2p_send(net_nfc_error_e result, void *user_data)
{
g_print("P2P send Completed %d\n", result);
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_h handle, void *user_data)
{
g_print("Target is Discovered\n");
global_handle = handle;
run_next_callback(user_data);
}
-void net_nfc_test_p2p_send(gpointer data,
- gpointer user_data)
+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;
- net_nfc_exchanger_data_h exch_data = NULL;
data_h rawdata = NULL;
net_nfc_create_ndef_message (&msg);
net_nfc_append_record_to_ndef_message (msg ,record);
net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
- if((result = net_nfc_client_create_exchanger_data(&exch_data, rawdata)) != NET_NFC_OK)
- {
- net_nfc_free_data(rawdata);
-
- g_printerr("create exchanger data is failed\n");
- return;
- }
- net_nfc_free_data(rawdata);
g_print("Handle is %#x\n", GPOINTER_TO_UINT(global_handle));
- net_nfc_client_p2p_send(
- exch_data,
- global_handle,
- p2p_send,
- user_data);
+ result = net_nfc_client_p2p_send(global_handle,
+ rawdata,
+ p2p_send,
+ user_data);
+
+ g_print("net_nfc_client_p2p_send() Return(%d)\n", result);
+
+ net_nfc_free_data(rawdata);
}
-void net_nfc_test_p2p_send_sync(gpointer data,
- gpointer user_data)
+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;
- net_nfc_exchanger_data_h exch_data = NULL;
data_h 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_append_record_to_ndef_message (msg, record);
net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
- net_nfc_client_create_exchanger_data(&exch_data, rawdata);
- result = net_nfc_client_p2p_send_sync(exch_data, global_handle);
+ result = net_nfc_client_p2p_send_sync(global_handle, rawdata);
g_print(" P2P send sync result: %d\n", result);
+
+ net_nfc_free_data(rawdata);
+
run_next_callback(user_data);
}
-void net_nfc_test_p2p_set_device_discovered(gpointer data,
- gpointer user_data)
+void net_nfc_test_p2p_set_device_discovered(gpointer data, gpointer user_data)
{
g_print("Waiting for Device Discovered Singal\n");
g_print("Device Discovered set\n");
}
-void net_nfc_test_p2p_set_device_detached(gpointer data,
- gpointer user_data)
+void net_nfc_test_p2p_set_device_detached(gpointer data, gpointer user_data)
{
- net_nfc_client_p2p_set_device_detached(p2p_device_detached,
- user_data);
+ net_nfc_client_p2p_set_device_detached(p2p_device_detached, user_data);
}
-void net_nfc_test_p2p_set_data_received(gpointer data,
- gpointer user_data)
+void net_nfc_test_p2p_set_data_received(gpointer data, gpointer user_data)
{
- net_nfc_client_p2p_set_data_received(p2p_device_data_received,
- user_data);
+ 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)
projects / platform / core / connectivity / nfc-manager.git / commitdiff