client/net_nfc_client_phdc.c

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "net_nfc_typedef_internal.h"
  18 #include "net_nfc_debug_internal.h"
  19 #include "net_nfc_util_internal.h"
  20 #include "net_nfc_util_ndef_message.h"
  21 #include "net_nfc_util_gdbus_internal.h"
  22 #include "net_nfc_gdbus.h"
  23 #include "net_nfc_client.h"
  24 #include "net_nfc_client_manager.h"
  25 #include "net_nfc_client_phdc.h"
  26
  27 typedef struct _Phdc_SignalHandler PhdcSignalHandler;
  28
  29 static NetNfcGDbusPhdc *phdc_proxy = NULL;
  30 static PhdcSignalHandler phdc_signal_handler;
  31
  32 struct _Phdc_SignalHandler
  33 {
  34         net_nfc_client_phdc_transport_connect_indication phdc_transport_connect_indication_cb;
  35         net_nfc_client_phdc_transport_disconnect_indication phdc_transport_disconnect_indication_cb;
  36         net_nfc_client_phdc_data_received phdc_data_received_cb;
  37
  38         gpointer phdc_transport_connect_indication_data;
  39         gpointer phdc_transport_disconnect_indication_data;
  40         gpointer phdc_data_received_data;
  41 };
  42
  43
  44 static void _phdc_event_cb(NetNfcGDbusPhdc *object, gint arg_result,
  45                 guint arg_event,guint arg_user_data)
  46 {
  47         GVariant *parameter = (GVariant *)GUINT_TO_POINTER(arg_user_data);
  48
  49         NFC_DBG(" result [%d], event [%d], user_data [%p]",
  50                          arg_result, arg_event, parameter);
  51
  52         if (parameter != NULL)
  53         {
  54                 void *user_data;
  55                 net_nfc_client_phdc_event_cb callback;
  56
  57                 g_variant_get(parameter, "(uu)",
  58                         (guint *)&callback,
  59                         (guint *)&user_data);
  60
  61                 if (callback != NULL)
  62                 {
  63                         callback( arg_result, arg_event, user_data);
  64                 }
  65         }
  66
  67         if (arg_event == NET_NFC_LLCP_UNREGISTERED)
  68         {
  69                 g_variant_unref(parameter);
  70         }
  71
  72 }
  73
  74
  75 static void phdc_transport_disconnect_indication(GObject *source_object, gpointer user_data)
  76 {
  77         NFC_INFO(">>> SIGNAL arrived");
  78
  79         RET_IF(NULL == phdc_signal_handler.phdc_transport_disconnect_indication_cb);
  80
  81         phdc_signal_handler.phdc_transport_disconnect_indication_cb(
  82                         phdc_signal_handler.phdc_transport_disconnect_indication_data);
  83 }
  84
  85 static void phdc_transport_connect_indication(GObject *source_object,
  86                 guint arg_handle, gpointer user_data)
  87 {
  88         net_nfc_phdc_handle_h handle_info = NULL;
  89
  90         NFC_INFO(">>> SIGNAL arrived");
  91
  92         handle_info = GUINT_TO_POINTER(arg_handle);
  93
  94         RET_IF(NULL == phdc_signal_handler.phdc_transport_connect_indication_cb);
  95
  96         phdc_signal_handler.phdc_transport_connect_indication_cb(handle_info,
  97                         phdc_signal_handler.phdc_transport_connect_indication_data);
  98 }
  99
 100 static void phdc_call_send(GObject *source_object,GAsyncResult *res, gpointer user_data)
 101 {
 102         gboolean ret;
 103         GVariant *parameter = (GVariant *)user_data;
 104         GError *error = NULL;
 105         net_nfc_error_e out_result;
 106         net_nfc_client_phdc_send_completed callback;
 107         net_nfc_phdc_handle_h handle;
 108         void *user_param;
 109
 110         NFC_INFO(">>> phdc_call_send \n");
 111
 112         ret = net_nfc_gdbus_phdc_call_send_finish(NET_NFC_GDBUS_PHDC(source_object),
 113                         (gint *)&out_result, res, &error);
 114
 115         if (FALSE == ret)
 116         {
 117                 out_result = NET_NFC_IPC_FAIL;
 118
 119                 NFC_ERR("Can not finish phdc send: %s", error->message);
 120                 g_error_free(error);
 121         }
 122
 123         g_variant_get(parameter, "(uuu)",
 124         (guint *)&callback,
 125         (guint *)&user_param,
 126         (guint *)&handle);
 127
 128         NFC_INFO(">>> phdc_call_send  %p\n", handle);
 129
 130         if (callback != NULL)
 131         {
 132                 callback( out_result, user_param);
 133         }
 134
 135         g_variant_unref(parameter);
 136 }
 137
 138 static void phdc_device_data_received(GObject *source_object,GVariant *arg_data,
 139                 gpointer user_data)
 140 {
 141         data_s phdc_data = { NULL, };
 142
 143         NFC_INFO(">>> SIGNAL arrived");
 144
 145         RET_IF(NULL == phdc_signal_handler.phdc_data_received_cb);
 146
 147         net_nfc_util_gdbus_variant_to_data_s(arg_data, &phdc_data);
 148         phdc_signal_handler.phdc_data_received_cb(&phdc_data,
 149                         phdc_signal_handler.phdc_data_received_data);
 150
 151         net_nfc_util_free_data(&phdc_data);
 152 }
 153
 154 API net_nfc_error_e net_nfc_client_phdc_send(net_nfc_phdc_handle_h handle,
 155                 data_s *data, net_nfc_client_phdc_send_completed callback, void *user_data)
 156 {
 157         GVariant *arg_data;
 158         GVariant *parameter;
 159
 160         NFC_INFO(">>> net_nfc_client_phdc_send \n");
 161
 162         RETV_IF(NULL == phdc_proxy, NET_NFC_NOT_INITIALIZED);
 163
 164         /* prevent executing daemon when nfc is off */
 165         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 166
 167         parameter = g_variant_new("(uuu)",
 168                 GPOINTER_TO_UINT(callback),
 169                 GPOINTER_TO_UINT(user_data),
 170                 GPOINTER_TO_UINT(handle));
 171
 172
 173         arg_data = net_nfc_util_gdbus_data_to_variant(data);
 174
 175         net_nfc_gdbus_phdc_call_send(phdc_proxy,
 176                 GPOINTER_TO_UINT(handle),
 177                 arg_data,
 178                 net_nfc_client_gdbus_get_privilege(),
 179                 NULL,
 180                 phdc_call_send,
 181                 parameter);
 182
 183         return NET_NFC_OK;
 184 }
 185
 186
 187 API net_nfc_error_e net_nfc_client_phdc_send_sync(net_nfc_phdc_handle_h handle,
 188                 data_s *data)
 189 {
 190         gboolean ret;
 191         GVariant *arg_data;
 192         GError *error = NULL;
 193
 194         net_nfc_error_e out_result;
 195
 196         RETV_IF(NULL == phdc_proxy, NET_NFC_NOT_INITIALIZED);
 197
 198         /* prevent executing daemon when nfc is off */
 199         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 200
 201         arg_data = net_nfc_util_gdbus_data_to_variant(data);
 202
 203         ret = net_nfc_gdbus_phdc_call_send_sync(phdc_proxy,
 204                         GPOINTER_TO_UINT(handle),
 205                         arg_data,
 206                         net_nfc_client_gdbus_get_privilege(),
 207                         (gint *)&out_result,
 208                         NULL,
 209                         &error);
 210
 211         if(FALSE == ret)
 212         {
 213                 NFC_ERR("phdc send (sync call) failed: %s", error->message);
 214
 215                 g_error_free(error);
 216                 out_result = NET_NFC_IPC_FAIL;
 217         }
 218
 219         return out_result;
 220 }
 221
 222 API net_nfc_error_e net_nfc_client_phdc_register(net_nfc_phdc_role_e role,
 223                 const char *san,net_nfc_client_phdc_event_cb callback, void *user_data)
 224 {
 225         GError *error = NULL;
 226         GVariant *parameter;
 227         net_nfc_error_e result = NET_NFC_OK;
 228
 229         RETV_IF(NULL == phdc_proxy, NET_NFC_NOT_INITIALIZED);
 230
 231         /* prevent executing daemon when nfc is off */
 232         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 233
 234         parameter = g_variant_new("(uu)",
 235                         GPOINTER_TO_UINT(callback),
 236                         GPOINTER_TO_UINT(user_data));
 237
 238         if (net_nfc_gdbus_phdc_call_register_role_sync(phdc_proxy,
 239                                 role,
 240                                 san,
 241                                 GPOINTER_TO_UINT(parameter),
 242                                 net_nfc_client_gdbus_get_privilege(),
 243                                 (gint *)&result,
 244                                 NULL,
 245                                 &error) == FALSE)
 246         {
 247                 NFC_ERR("phdc register role(sync call) failed: %s", error->message);
 248                 g_error_free(error);
 249                 result = NET_NFC_IPC_FAIL;
 250                 g_variant_unref(parameter);
 251         }
 252
 253         return result;
 254 }
 255
 256 API net_nfc_error_e net_nfc_client_phdc_unregister( net_nfc_phdc_role_e role,
 257                 const char *san)
 258 {
 259         GError *error = NULL;
 260         net_nfc_error_e result = NET_NFC_OK;
 261
 262         RETV_IF(NULL == phdc_proxy, NET_NFC_NOT_INITIALIZED);
 263
 264         /* prevent executing daemon when nfc is off */
 265         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 266
 267         if (net_nfc_gdbus_phdc_call_unregister_role_sync(phdc_proxy,
 268                                 role,
 269                                 san,
 270                                 net_nfc_client_gdbus_get_privilege(),
 271                                 (gint *)&result,
 272                                 NULL,
 273                                 &error) == FALSE)
 274         {
 275                 NFC_ERR("phdc unregister role(sync call) failed: %s", error->message);
 276                 g_error_free(error);
 277
 278                 result = NET_NFC_IPC_FAIL;
 279         }
 280
 281         return result;
 282 }
 283
 284
 285 API void net_nfc_client_phdc_set_transport_connect_indication(
 286                 net_nfc_client_phdc_transport_connect_indication callback, void *user_data)
 287 {
 288         RET_IF(NULL == callback);
 289
 290         phdc_signal_handler.phdc_transport_connect_indication_cb = callback;
 291         phdc_signal_handler.phdc_transport_connect_indication_data = user_data;
 292 }
 293
 294 API void net_nfc_client_phdc_set_transport_disconnect_indication(
 295                 net_nfc_client_phdc_transport_disconnect_indication callback, void *user_data)
 296 {
 297         RET_IF(NULL == callback);
 298
 299         phdc_signal_handler.phdc_transport_disconnect_indication_cb = callback;
 300         phdc_signal_handler.phdc_transport_disconnect_indication_data = user_data;
 301 }
 302
 303 API void net_nfc_client_phdc_set_data_received(
 304                 net_nfc_client_phdc_data_received callback, void *user_data)
 305 {
 306         RET_IF(NULL == callback);
 307
 308         phdc_signal_handler.phdc_data_received_cb = callback;
 309         phdc_signal_handler.phdc_data_received_data = user_data;
 310 }
 311
 312 API void net_nfc_client_phdc_unset_transport_connect_indication(void)
 313 {
 314         phdc_signal_handler.phdc_transport_connect_indication_cb = NULL;
 315         phdc_signal_handler.phdc_transport_connect_indication_data= NULL;
 316 }
 317
 318
 319 API void net_nfc_client_phdc_unset_transport_disconnect_indication(void)
 320 {
 321         phdc_signal_handler.phdc_transport_disconnect_indication_cb = NULL;
 322         phdc_signal_handler.phdc_transport_disconnect_indication_data = NULL;
 323 }
 324
 325 API void net_nfc_client_phdc_unset_data_received(void)
 326 {
 327         phdc_signal_handler.phdc_data_received_cb = NULL;
 328         phdc_signal_handler.phdc_data_received_data = NULL;
 329 }
 330
 331 net_nfc_error_e net_nfc_client_phdc_init(void)
 332 {
 333         GError *error = NULL;
 334
 335         if (phdc_proxy)
 336         {
 337                 NFC_WARN("Already initialized");
 338                 return NET_NFC_OK;
 339         }
 340
 341         phdc_proxy = net_nfc_gdbus_phdc_proxy_new_for_bus_sync(
 342                         G_BUS_TYPE_SYSTEM,
 343                         G_DBUS_PROXY_FLAGS_NONE,
 344                         "org.tizen.NetNfcService",
 345                         "/org/tizen/NetNfcService/Phdc",
 346                         NULL,
 347                         &error);
 348         if (NULL == phdc_proxy)
 349         {
 350                 NFC_ERR("Can not create proxy : %s", error->message);
 351                 g_error_free(error);
 352
 353                 return NET_NFC_UNKNOWN_ERROR;
 354         }
 355
 356         net_nfc_client_phdc_unset_transport_connect_indication();
 357         net_nfc_client_phdc_unset_transport_disconnect_indication();
 358         net_nfc_client_phdc_unset_data_received();
 359
 360         g_signal_connect(phdc_proxy, "phdc_connect",
 361                         G_CALLBACK(phdc_transport_connect_indication), NULL);
 362
 363         g_signal_connect(phdc_proxy, "phdc_disconnect",
 364                         G_CALLBACK(phdc_transport_disconnect_indication), NULL);
 365
 366         g_signal_connect(phdc_proxy, "phdc_received",
 367                         G_CALLBACK(phdc_device_data_received), NULL);
 368
 369         g_signal_connect(phdc_proxy, "phdc-event", G_CALLBACK(_phdc_event_cb), NULL);
 370
 371
 372         return NET_NFC_OK;
 373 }
 374
 375 void net_nfc_client_phdc_deinit(void)
 376 {
 377         if (phdc_proxy)
 378         {
 379                 g_object_unref(phdc_proxy);
 380                 phdc_proxy = NULL;
 381         }
 382
 383         net_nfc_client_phdc_unset_transport_connect_indication();
 384         net_nfc_client_phdc_unset_transport_disconnect_indication();
 385         net_nfc_client_phdc_unset_data_received();
 386
 387 }
 388