client/net_nfc_neard.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <glib.h>
   4
   5 #include "vconf.h"
   6
   7 #include "net_nfc.h"
   8 #include "net_nfc_typedef.h"
   9 #include "net_nfc_debug_internal.h"
  10 #include "net_nfc_util_internal.h"
  11 #include "net_nfc_util_ndef_message.h"
  12 #include "net_nfc_client_util.h"
  13
  14 #include "neardal.h"
  15
  16 /* TODO get real data */
  17 #define NET_NFC_JEWEL_PICC_MAX_SIZE             116
  18 #define NET_NFC_MIFARE_ULTRA_PICC_MAX_SIZE      48
  19 #define NET_NFC_FELICA_PICC_MAX_SIZE            256
  20 #define NET_NFC_MIFARE_DESFIRE_PICC_MAX_SIZE    2048
  21
  22 typedef struct _net_nfc_client_cb
  23 {
  24         net_nfc_client_manager_set_active_completed active_cb;
  25         void *active_ud;
  26
  27         /* callback for power status changed */
  28         net_nfc_client_manager_activated activated_cb;
  29         void *activated_ud;
  30
  31         net_nfc_client_tag_tag_discovered tag_discovered_cb;
  32         void *tag_discovered_ud;
  33         net_nfc_client_tag_tag_detached tag_detached_cb;
  34         void *tag_detached_ud;
  35
  36         net_nfc_client_ndef_read_completed ndef_read_cb;
  37         void *ndef_read_ud;
  38         net_nfc_client_ndef_write_completed ndef_write_cb;
  39         void *ndef_write_ud;
  40
  41         net_nfc_client_p2p_device_discovered p2p_discovered_cb;
  42         void *p2p_discovered_ud;
  43         net_nfc_client_p2p_device_detached p2p_detached_cb;
  44         void *p2p_detached_ud;
  45         net_nfc_client_p2p_send_completed p2p_send_completed_cb;
  46         void *p2p_send_completed_ud;
  47         net_nfc_client_p2p_data_received p2p_data_received_cb;
  48         void *p2p_data_received_ud;
  49         net_nfc_p2p_connection_handover_completed_cb p2p_handover_cb;
  50         void *p2p_handover_ud;
  51 } net_nfc_client_cb;
  52
  53 static net_nfc_client_cb client_cb;
  54
  55 static char *nfc_adapter_path;
  56 static bool nfc_adapter_powered;
  57 static bool nfc_adapter_polling;
  58 static char *nfc_adapter_mode;
  59 static neardal_tag *tag;
  60 static neardal_dev *dev;
  61 static data_s *rawNDEF;
  62 static net_nfc_target_info_s *target_info;
  63 static net_nfc_target_handle_s *target_handle;
  64 static net_nfc_connection_handover_info_s *handover_info;
  65 static bool read_flag;
  66
  67 static net_nfc_error_e _convert_error_code(errorCode_t error_code)
  68 {
  69         switch (error_code) {
  70         case NEARDAL_SUCCESS:
  71                 return NET_NFC_OK;
  72         case NEARDAL_ERROR_GENERAL_ERROR:
  73                 return NET_NFC_UNKNOWN_ERROR;
  74         case NEARDAL_ERROR_INVALID_PARAMETER:
  75                 return NET_NFC_INVALID_PARAM;
  76         case NEARDAL_ERROR_NO_MEMORY:
  77                 return NET_NFC_ALLOC_FAIL;
  78         case NEARDAL_ERROR_DBUS:
  79         case NEARDAL_ERROR_DBUS_CANNOT_CREATE_PROXY:
  80         case NEARDAL_ERROR_DBUS_CANNOT_INVOKE_METHOD:
  81         case NEARDAL_ERROR_DBUS_INVOKE_METHOD_ERROR:
  82                 return NET_NFC_OPERATION_FAIL;
  83         case NEARDAL_ERROR_NO_ADAPTER:
  84                 return NET_NFC_NOT_SUPPORTED;
  85         case NEARDAL_ERROR_POLLING_ALREADY_ACTIVE:
  86                 return NET_NFC_ALREADY_REGISTERED;
  87         case NEARDAL_ERROR_NO_TAG:
  88         case NEARDAL_ERROR_INVALID_RECORD:
  89                 return NET_NFC_TAG_READ_FAILED;
  90         case NEARDAL_ERROR_NO_RECORD:
  91                 return NET_NFC_NO_DATA_FOUND;
  92         case NEARDAL_ERROR_NO_DEV:
  93                 return NET_NFC_TARGET_IS_MOVED_AWAY;
  94         default:
  95                 return NET_NFC_UNKNOWN_ERROR;
  96         }
  97 }
  98
  99 static int _convert_target_type(const char *type)
 100 {
 101         int t_type;
 102
 103         /* TODO tag sub types */
 104
 105         if (type == NULL)
 106                 return NET_NFC_UNKNOWN_TARGET;
 107
 108         if (!g_strcmp0(type, "Type 1"))
 109                 t_type = NET_NFC_JEWEL_PICC;
 110         else if (!g_strcmp0(type, "Type 2"))
 111                 t_type = NET_NFC_MIFARE_ULTRA_PICC;
 112         /*
 113                 NET_NFC_MIFARE_MINI_PICC
 114                 NET_NFC_MIFARE_1K_PICC
 115                 NET_NFC_MIFARE_4K_PICC
 116                 NET_NFC_MIFARE_ULTRA_PICC
 117         */
 118         else if (!g_strcmp0(type, "Type 3"))
 119                 t_type = NET_NFC_FELICA_PICC;
 120         else if (!g_strcmp0(type, "Type 4"))
 121                 t_type = NET_NFC_MIFARE_DESFIRE_PICC;
 122         else if (!g_strcmp0(type, "Target"))
 123                 t_type = NET_NFC_NFCIP1_TARGET;
 124         else if (!g_strcmp0(type, "Initiator"))
 125                 t_type = NET_NFC_NFCIP1_INITIATOR;
 126         else
 127                 t_type = NET_NFC_UNKNOWN_TARGET;
 128
 129         return t_type;
 130 }
 131
 132 static const char *carrier2string(net_nfc_conn_handover_carrier_type_e type)
 133 {
 134         switch (type) {
 135         case NET_NFC_CONN_HANDOVER_CARRIER_BT:
 136                 return "bluetooth";
 137         case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS:
 138                 return "wifi";
 139         default:
 140                 return "unknown";
 141         }
 142
 143         return NULL;
 144 }
 145
 146 static uint32_t _get_tag_id(const char *name)
 147 {
 148         uint32_t id;
 149         char **s;
 150
 151         s = g_strsplit(name, "tag", 2);
 152         id = atoi(s[1]);
 153         g_strfreev(s);
 154
 155         return id;
 156 }
 157
 158 static uint32_t _get_dev_id(const char *name)
 159 {
 160         uint32_t id;
 161         char **s;
 162
 163         s = g_strsplit(name, "device", 2);
 164         id = atoi(s[1]);
 165         g_strfreev(s);
 166
 167         return id;
 168 }
 169
 170 static bool _check_ndef(uint8_t *ndef_card_state,
 171                                         int *max_data_size,
 172                                         int *real_data_size)
 173 {
 174         if (ndef_card_state == NULL ||
 175                 max_data_size == NULL || real_data_size == NULL) {
 176
 177                 return false;
 178         }
 179
 180         if (tag == NULL || rawNDEF == NULL)
 181                 return false;
 182
 183         if (tag->readOnly)
 184                 *ndef_card_state = NET_NFC_NDEF_CARD_READ_ONLY;
 185         else
 186                 *ndef_card_state = NET_NFC_NDEF_CARD_READ_WRITE;
 187
 188         /* TODO get real data */
 189         switch (_convert_target_type(tag->type)) {
 190         case NET_NFC_JEWEL_PICC:
 191                 *max_data_size = NET_NFC_JEWEL_PICC_MAX_SIZE;
 192                 break;
 193
 194         case NET_NFC_MIFARE_ULTRA_PICC:
 195                 *max_data_size = NET_NFC_MIFARE_ULTRA_PICC_MAX_SIZE;
 196                 break;
 197
 198         case NET_NFC_FELICA_PICC:
 199                 *max_data_size = NET_NFC_FELICA_PICC_MAX_SIZE;
 200                 break;
 201
 202         case NET_NFC_MIFARE_DESFIRE_PICC:
 203                 *max_data_size = NET_NFC_MIFARE_DESFIRE_PICC_MAX_SIZE;
 204                 break;
 205         }
 206
 207         *real_data_size = rawNDEF->length;
 208
 209         return true;
 210 }
 211
 212 static void _adapter_added_cb(const char *name, void *user_data)
 213 {
 214         NFC_DBG("adapter added %s", name);
 215
 216         if (nfc_adapter_path) {
 217                 g_free(nfc_adapter_path);
 218                 nfc_adapter_path = NULL;
 219         }
 220
 221         if (name != NULL)
 222                 nfc_adapter_path = g_strdup(name);
 223 }
 224
 225 static void _adapter_removed_cb(const char *name, void *user_data)
 226 {
 227         NFC_DBG("adapter removed %s", name);
 228
 229         if (nfc_adapter_path) {
 230                 g_free(nfc_adapter_path);
 231                 nfc_adapter_path = NULL;
 232         }
 233 }
 234
 235 static void _adapter_property_changed_cb(char *name, char *property,
 236                                         void *value, void *user_data)
 237 {
 238         NFC_DBG("adapter name %s, property %s", name, property);
 239
 240         if (!g_strcmp0(property, "Polling")) {
 241                 if ((int *) value == 0)
 242                         nfc_adapter_polling = false;
 243                 else
 244                         nfc_adapter_polling = true;
 245         } else if (!g_strcmp0(property, "Mode")) {
 246                 if (nfc_adapter_mode) {
 247                         g_free(nfc_adapter_mode);
 248                         nfc_adapter_mode = NULL;
 249                 }
 250
 251                 nfc_adapter_mode = g_strdup((char *)value);
 252         } else if (!g_strcmp0(property, "Powered")) {
 253                 if ((int *) value == 0)
 254                         nfc_adapter_powered = false;
 255                 else
 256                         nfc_adapter_powered = true;
 257
 258                 if (client_cb.activated_cb != NULL)
 259                         client_cb.activated_cb(nfc_adapter_powered, client_cb.activated_ud);
 260         }
 261 }
 262
 263 static void _power_completed_cb(errorCode_t error_code, void *user_data)
 264 {
 265         errorCode_t err;
 266         neardal_adapter *neard_adapter = NULL;
 267         bool powered;
 268         net_nfc_error_e result;
 269
 270         NFC_DBG("power completed adapter path %s", nfc_adapter_path);
 271         if (nfc_adapter_path == NULL)
 272                 goto exit;
 273
 274         err = neardal_get_adapter_properties(nfc_adapter_path, &neard_adapter);
 275         if (err != NEARDAL_SUCCESS)
 276                 goto exit;
 277
 278         NFC_DBG("power completed %d", neard_adapter->powered);
 279         powered = (neard_adapter->powered) ? true : false;
 280
 281         if (powered == true) {
 282                 if (nfc_adapter_polling == false) {
 283                         err = neardal_start_poll_loop(nfc_adapter_path,
 284                                                 NEARD_ADP_MODE_DUAL);
 285
 286                         if (err == NEARDAL_SUCCESS)
 287                                 nfc_adapter_polling = true;
 288                 }
 289         }
 290
 291 exit:
 292         if (client_cb.active_cb != NULL && client_cb.active_ud != NULL) {
 293                 result = _convert_error_code(error_code);
 294
 295                 client_cb.active_cb(result, client_cb.active_ud);
 296
 297                 client_cb.active_cb = NULL;
 298                 client_cb.active_ud = NULL;
 299         }
 300 }
 301
 302 static void _tag_found_cb(const char *tagName, void *user_data)
 303 {
 304         NFC_DBG("NFC tag found tagName: %s", tagName);
 305
 306         if (neardal_get_tag_properties(tagName, &tag) != NEARDAL_SUCCESS)
 307                 return;
 308         if (tag == NULL)
 309                 return;
 310
 311         net_nfc_manager_util_play_sound(NET_NFC_TASK_START);
 312         if (neardal_tag_get_rawNDEF(tag->name)
 313                                 != NEARDAL_SUCCESS) {
 314                 NFC_DBG("Failed to get rawNDEF");
 315                 return;
 316         }
 317
 318         read_flag = true;
 319 }
 320
 321 static void _tag_lost_cb(const char *tagName, void *user_data)
 322 {
 323         NFC_DBG("NFC tag lost");
 324
 325         if (tag != NULL) {
 326                 neardal_free_tag(tag);
 327                 tag = NULL;
 328         }
 329
 330         if (rawNDEF != NULL) {
 331                 net_nfc_util_free_data(rawNDEF);
 332                 rawNDEF = NULL;
 333         }
 334
 335         if (target_handle != NULL) {
 336                 g_free(target_handle);
 337                 target_handle = NULL;
 338         }
 339
 340         if (target_info != NULL) {
 341                 g_free(target_info);
 342                 target_info = NULL;
 343         }
 344
 345         if (nfc_adapter_polling == true)
 346                 return;
 347
 348         if (neardal_start_poll_loop(nfc_adapter_path, NEARD_ADP_MODE_DUAL)
 349                                                         == NEARDAL_SUCCESS)
 350                 nfc_adapter_polling = true;
 351
 352         if (client_cb.tag_detached_cb != NULL)
 353                 client_cb.tag_detached_cb(client_cb.tag_detached_ud);
 354 }
 355
 356 static void _create_target_info(data_s *data)
 357 {
 358         uint8_t ndefCardstate;
 359         int actualDataSize, maxDataSize = 0;
 360         bool ndef_support;
 361
 362         if (target_info == NULL)
 363                 target_info = g_try_malloc0(sizeof(net_nfc_target_info_s));
 364
 365         if (target_info == NULL) {
 366                 NFC_DBG("target_info mem alloc is failed");
 367                 return;
 368         }
 369         if (target_handle == NULL)
 370                 target_handle = g_try_malloc0(sizeof(net_nfc_target_handle_s));
 371
 372         if (target_handle == NULL) {
 373                 NFC_DBG("handle mem alloc is failed");
 374                 return;
 375         }
 376
 377         target_handle->connection_id = _get_tag_id(tag->name);
 378         target_handle->connection_type = NET_NFC_TAG_CONNECTION;
 379         target_handle->target_type = _convert_target_type(tag->type);
 380
 381         ndef_support =  _check_ndef(&ndefCardstate, &maxDataSize,
 382                                                 &actualDataSize);
 383
 384         if (ndef_support == false) {
 385                 ndefCardstate = 0;
 386                 maxDataSize   = -1;
 387                 actualDataSize  = -1;
 388         }
 389
 390         target_info->ndefCardState = ndefCardstate;
 391         target_info->actualDataSize = actualDataSize;
 392         target_info->maxDataSize = maxDataSize;
 393         target_info->devType = _convert_target_type(tag->type);
 394         target_info->handle = target_handle;
 395         target_info->is_ndef_supported = ndef_support;
 396         target_info->number_of_keys = 0;
 397         target_info->tag_info_list = NULL;
 398         target_info->raw_data = *data;
 399 }
 400
 401 static void _read_completed_cb(GVariant *ret, void *user_data)
 402 {
 403         gconstpointer value;
 404         gsize length;
 405         ndef_message_s *ndef = NULL;
 406         net_nfc_error_e result = NET_NFC_TAG_READ_FAILED;
 407
 408         NFC_DBG("read completed cb adapter path %s", nfc_adapter_path);
 409
 410         if (ret == NULL)
 411                 goto exit;
 412
 413         value = g_variant_get_data(ret);
 414         length = g_variant_get_size(ret);
 415
 416         if (length < 0)
 417                 goto exit;
 418
 419         if (rawNDEF != NULL) {
 420                 net_nfc_util_free_data(rawNDEF);
 421                 rawNDEF = NULL;
 422         }
 423
 424         rawNDEF = g_try_malloc0(sizeof(data_s));
 425         if (rawNDEF == NULL)
 426                 goto exit;
 427
 428         rawNDEF->length = (int)length;
 429         rawNDEF->buffer = g_try_malloc0(rawNDEF->length);
 430         if (rawNDEF->length > 0 && rawNDEF->buffer == NULL) {
 431                 g_free(rawNDEF);
 432                 goto exit;
 433         }
 434
 435         memcpy(rawNDEF->buffer, value, rawNDEF->length);
 436
 437         net_nfc_app_util_process_ndef(rawNDEF);
 438         _create_target_info(rawNDEF);
 439
 440         if (net_nfc_util_create_ndef_message(&ndef) != NET_NFC_OK) {
 441                 NFC_DBG("ndef memory alloc fail..");
 442                 goto exit;
 443         }
 444         result = net_nfc_util_convert_rawdata_to_ndef_message(
 445                                                 rawNDEF, ndef);
 446 exit:
 447         if (client_cb.tag_discovered_cb != NULL && read_flag == true) {
 448                 client_cb.tag_discovered_cb(target_info,
 449                                         client_cb.tag_discovered_ud);
 450                 read_flag = false;
 451                 return;
 452         }
 453
 454         if (client_cb.ndef_read_cb != NULL) {
 455                 client_cb.ndef_read_cb(result, ndef, client_cb.ndef_read_ud);
 456
 457                 net_nfc_util_free_ndef_message(ndef);
 458                 client_cb.ndef_read_cb = NULL;
 459                 client_cb.ndef_read_ud = NULL;
 460         }
 461 }
 462
 463 static void _write_completed_cb(errorCode_t error_code, void *user_data)
 464 {
 465         net_nfc_error_e result;
 466
 467         NFC_DBG("write completed cb adapter path %s", nfc_adapter_path);
 468
 469         result = _convert_error_code(error_code);
 470
 471         if (client_cb.ndef_write_cb != NULL) {
 472                 client_cb.ndef_write_cb(result, client_cb.ndef_write_ud);
 473
 474                 client_cb.ndef_write_cb = NULL;
 475                 client_cb.ndef_write_ud = NULL;
 476         }
 477 }
 478
 479 static void _device_found_cb(const char *devName, void *user_data)
 480 {
 481         int devType = 0;
 482
 483         NFC_DBG("p2p device found %s", devName);
 484         if (neardal_get_dev_properties(devName, &dev) != NEARDAL_SUCCESS)
 485                 return;
 486
 487         if (target_handle == NULL)
 488                 target_handle = g_try_malloc0(sizeof(net_nfc_target_handle_s));
 489
 490         if (target_handle == NULL) {
 491                 NFC_DBG("handle mem alloc is failed");
 492                 return;
 493         }
 494
 495
 496         devType = _convert_target_type(nfc_adapter_mode);
 497         if (devType == NET_NFC_NFCIP1_INITIATOR)
 498                 target_handle->connection_type = NET_NFC_P2P_CONNECTION_TARGET;
 499         else if (devType == NET_NFC_NFCIP1_TARGET)
 500                 target_handle->connection_type =
 501                                         NET_NFC_P2P_CONNECTION_INITIATOR;
 502         target_handle->connection_id = _get_dev_id(devName);
 503         target_handle->target_type = devType;
 504
 505         if (client_cb.p2p_discovered_cb != NULL)
 506                 client_cb.p2p_discovered_cb(target_handle, client_cb.p2p_discovered_ud);
 507 }
 508
 509 static void _device_lost_cb(const char *devName, void *user_data)
 510 {
 511         errorCode_t err;
 512
 513         NFC_DBG("p2p device lost %s", devName);
 514         if (target_handle != NULL) {
 515                 g_free(target_handle);
 516                 target_handle = NULL;
 517         }
 518
 519         if (nfc_adapter_polling == true)
 520                 goto exit;
 521
 522         if (nfc_adapter_path == NULL)
 523                 goto exit;
 524
 525         err = neardal_start_poll_loop(nfc_adapter_path,
 526                                                 NEARD_ADP_MODE_DUAL);
 527         if (err != NEARDAL_SUCCESS)
 528                 goto exit;
 529
 530         nfc_adapter_polling = true;
 531
 532 exit:
 533         if (client_cb.p2p_detached_cb != NULL)
 534                 client_cb.p2p_detached_cb(client_cb.p2p_detached_ud);
 535 }
 536
 537 static void _p2p_received_cb(GVariant *ret, void *user_data)
 538 {
 539         gconstpointer value;
 540         gsize length;
 541
 542         NFC_DBG("p2p received cb adapter path %s", nfc_adapter_path);
 543         if (nfc_adapter_path == NULL)
 544                 return;
 545
 546         if (ret == NULL)
 547                 return;
 548
 549         value = g_variant_get_data(ret);
 550         length = g_variant_get_size(ret);
 551
 552         if (length < 0)
 553                 return;
 554
 555         if (rawNDEF != NULL) {
 556                 net_nfc_util_free_data(rawNDEF);
 557                 rawNDEF = NULL;
 558         }
 559
 560         rawNDEF = g_try_malloc0(sizeof(data_s));
 561         if (rawNDEF == NULL)
 562                 return;
 563
 564         rawNDEF->length = (int)length;
 565         rawNDEF->buffer = g_try_malloc0(rawNDEF->length);
 566         if (rawNDEF->buffer == NULL) {
 567                 g_free(rawNDEF);
 568                 return;
 569         }
 570
 571         memcpy(rawNDEF->buffer, value, rawNDEF->length);
 572
 573         net_nfc_app_util_process_ndef(rawNDEF);
 574
 575         if (client_cb.p2p_data_received_cb != NULL)
 576                 client_cb.p2p_data_received_cb(rawNDEF, client_cb.p2p_data_received_ud);
 577 }
 578
 579 net_nfc_error_e net_nfc_neard_p2p_connection_handover(
 580                 net_nfc_target_handle_s *handle,
 581                 net_nfc_conn_handover_carrier_type_e arg_type,
 582                 net_nfc_p2p_connection_handover_completed_cb callback,
 583                 void *cb_data)
 584 {
 585         neardal_record *record;
 586         const char *carrier;
 587
 588         NFC_DBG("neard send p2p handover");
 589
 590         if (target_handle == NULL || handle != target_handle)
 591                 return NET_NFC_TARGET_IS_MOVED_AWAY;
 592
 593         carrier = carrier2string(arg_type);
 594
 595         if (carrier == NULL)
 596                 return NET_NFC_NOT_SUPPORTED;
 597
 598         record = g_try_malloc0(sizeof(neardal_record));
 599         if (record == NULL)
 600                 return NET_NFC_ALLOC_FAIL;
 601
 602         record->name = g_strdup(dev->name);
 603         record->type = g_strdup("Handover");
 604         record->carrier = g_strdup(carrier);
 605
 606         if (neardal_dev_push(record) != NEARDAL_SUCCESS) {
 607                 neardal_free_record(record);
 608                 return NET_NFC_P2P_SEND_FAIL;
 609         }
 610
 611         if (handover_info == NULL)
 612                 handover_info = g_try_malloc0(
 613                         sizeof(net_nfc_connection_handover_info_s));
 614
 615         if (handover_info == NULL) {
 616                 NFC_DBG("handover_info mem alloc is failed");
 617                 return NET_NFC_ALLOC_FAIL;
 618         }
 619
 620         handover_info->type = arg_type;
 621         handover_info->data.buffer = NULL;
 622         handover_info->data.length = 0;
 623
 624         neardal_free_record(record);
 625
 626         client_cb.p2p_handover_cb = callback;
 627         client_cb.p2p_handover_ud = cb_data;
 628
 629         return NET_NFC_OK;
 630 }
 631
 632 static void _p2p_send_completed_cb(errorCode_t error_code, void *user_data)
 633 {
 634         net_nfc_error_e result;
 635
 636         NFC_DBG("p2p send completed cb error code %d", error_code);
 637
 638         result = _convert_error_code(error_code);
 639
 640         if (client_cb.p2p_send_completed_cb != NULL)
 641                 client_cb.p2p_send_completed_cb(result,
 642                                 client_cb.p2p_send_completed_ud);
 643
 644         if (client_cb.p2p_handover_cb != NULL) {
 645                 if (handover_info != NULL) {
 646                         client_cb.p2p_handover_cb(result, handover_info->type,
 647                                         &(handover_info->data),
 648                                         client_cb.p2p_handover_ud);
 649
 650                         g_free(handover_info);
 651                         handover_info = NULL;
 652                 }
 653
 654                 client_cb.p2p_handover_cb = NULL;
 655                 client_cb.p2p_handover_ud = NULL;
 656         }
 657 }
 658
 659 net_nfc_error_e net_nfc_neard_send_p2p(net_nfc_target_handle_s *handle, data_s *data,
 660                         net_nfc_client_p2p_send_completed callback, void *user_data)
 661 {
 662         neardal_record *record;
 663
 664         NFC_DBG("neard send p2p");
 665
 666         if (target_handle == NULL || handle != target_handle)
 667                 return NET_NFC_TARGET_IS_MOVED_AWAY;
 668
 669         if ((data->buffer == NULL && data->length != 0) ||
 670                 (data->buffer != NULL && data->length == 0))
 671                 return NET_NFC_NULL_PARAMETER;
 672
 673         record = g_try_malloc0(sizeof(neardal_record));
 674         if (record == NULL)
 675                 return NET_NFC_ALLOC_FAIL;
 676
 677         record->name = g_strdup(dev->name);
 678         record->type = g_strdup("Raw");
 679         record->rawNDEF = g_try_malloc0(data->length);
 680         if (record->rawNDEF == NULL) {
 681                 neardal_free_record(record);
 682                 return NET_NFC_ALLOC_FAIL;
 683         }
 684
 685         memcpy(record->rawNDEF, data->buffer, data->length);
 686         record->rawNDEFSize = data->length;
 687
 688         if (neardal_dev_push(record) != NEARDAL_SUCCESS) {
 689                 neardal_free_record(record);
 690                 return NET_NFC_TAG_WRITE_FAILED;
 691         }
 692
 693         neardal_free_record(record);
 694
 695         NFC_DBG("neard send p2p successfully");
 696         client_cb.p2p_send_completed_cb = callback;
 697         client_cb.p2p_send_completed_ud = user_data;
 698         return NET_NFC_OK;
 699 }
 700
 701 net_nfc_error_e net_nfc_neard_get_current_tag_info(net_nfc_target_info_s **info)
 702 {
 703
 704         if (target_info == NULL)
 705                 return NET_NFC_NOT_CONNECTED;
 706         else
 707                 *info = target_info;
 708
 709         return NET_NFC_OK;
 710 }
 711
 712 net_nfc_error_e net_nfc_neard_get_current_target_handle(
 713                         net_nfc_target_handle_s **handle)
 714 {
 715         net_nfc_error_e result = NET_NFC_OK;
 716
 717         if (target_handle == NULL || target_info == NULL) {
 718                 result = NET_NFC_NOT_CONNECTED;
 719         } else if (NET_NFC_NFCIP1_INITIATOR == target_info->devType ||
 720                         NET_NFC_NFCIP1_TARGET == target_info->devType) {
 721                 if (handle)
 722                         *handle = target_info->handle;
 723
 724                 result = NET_NFC_OK;
 725         } else {
 726                 result = NET_NFC_NOT_CONNECTED;
 727         }
 728
 729         return result;
 730 }
 731
 732 net_nfc_error_e net_nfc_neard_read_tag(net_nfc_target_handle_s *handle,
 733                 net_nfc_client_ndef_read_completed callback, void *user_data)
 734 {
 735         if (handle != target_handle || rawNDEF == NULL)
 736                 return NET_NFC_TARGET_IS_MOVED_AWAY;
 737
 738         if (tag == NULL || tag->records == NULL)
 739                 return NET_NFC_TARGET_IS_MOVED_AWAY;
 740
 741         if (neardal_tag_get_rawNDEF(tag->name)
 742                                 != NEARDAL_SUCCESS) {
 743                 NFC_DBG("Failed to get rawNDEF");
 744                 return NET_NFC_TAG_READ_FAILED;
 745         }
 746
 747         client_cb.ndef_read_cb = callback;
 748         client_cb.ndef_read_ud = user_data;
 749
 750         return NET_NFC_OK;
 751 }
 752
 753 net_nfc_error_e net_nfc_neard_write_ndef(net_nfc_target_handle_s *handle,
 754                                         data_s *data,
 755                                         net_nfc_client_ndef_write_completed callback,
 756                                         void *user_data)
 757 {
 758         neardal_record *record;
 759
 760         NFC_DBG("write ndef message");
 761         if (target_handle == NULL || handle != target_handle)
 762                 return NET_NFC_TARGET_IS_MOVED_AWAY;
 763
 764         if ((data->buffer == NULL && data->length != 0) ||
 765                 (data->buffer != NULL && data->length == 0))
 766                 return NET_NFC_NULL_PARAMETER;
 767
 768         record = g_try_malloc0(sizeof(neardal_record));
 769         if (record == NULL)
 770                 return NET_NFC_ALLOC_FAIL;
 771
 772         if (tag->records != NULL)
 773                 record->name = g_strdup(tag->records[0]);
 774         else
 775                 record->name = g_strdup(tag->name);
 776         record->type = g_strdup("Raw");
 777         record->rawNDEF = g_try_malloc0(data->length);
 778         if (record->rawNDEF == NULL) {
 779                 neardal_free_record(record);
 780                 return NET_NFC_ALLOC_FAIL;
 781         }
 782
 783         client_cb.ndef_write_cb = callback;
 784         client_cb.ndef_write_ud = user_data;
 785
 786         memcpy(record->rawNDEF, data->buffer, data->length);
 787         record->rawNDEFSize = data->length;
 788
 789         if (neardal_tag_write(record) != NEARDAL_SUCCESS) {
 790                 neardal_free_record(record);
 791                 return NET_NFC_TAG_WRITE_FAILED;
 792         }
 793
 794         neardal_free_record(record);
 795
 796         return NET_NFC_OK;
 797 }
 798
 799 bool net_nfc_neard_is_tag_connected(void)
 800 {
 801         if (tag == NULL)
 802                 return false;
 803
 804         return true;
 805 }
 806
 807 net_nfc_error_e net_nfc_neard_set_active(int state,
 808                 net_nfc_client_manager_set_active_completed callback,
 809                 void *user_data)
 810 {
 811         errorCode_t err;
 812
 813         NFC_DBG("set active: %d", state);
 814
 815         if (state == nfc_adapter_powered)
 816                 return NET_NFC_OK;
 817
 818         RETV_IF(NULL == nfc_adapter_path, NET_NFC_NOT_INITIALIZED);
 819
 820         client_cb.active_cb = callback;
 821         client_cb.active_ud = user_data;
 822
 823         if (nfc_adapter_polling == true)
 824                 neardal_stop_poll(nfc_adapter_path);
 825
 826         err = neardal_set_adapter_property(nfc_adapter_path,
 827                         NEARD_ADP_PROP_POWERED, (void *) state);
 828         if (err != NEARDAL_SUCCESS)
 829                 return NET_NFC_OPERATION_FAIL;
 830
 831         return NET_NFC_OK;
 832 }
 833
 834 void net_nfc_neard_set_p2p_discovered(
 835                 net_nfc_client_p2p_device_discovered callback, void *user_data)
 836 {
 837         client_cb.p2p_discovered_cb = callback;
 838         client_cb.p2p_discovered_ud = user_data;
 839 }
 840
 841 void net_nfc_neard_unset_p2p_discovered(void)
 842 {
 843         client_cb.p2p_discovered_cb = NULL;
 844         client_cb.p2p_discovered_ud = NULL;
 845 }
 846
 847 void net_nfc_neard_set_p2p_detached(
 848                 net_nfc_client_p2p_device_detached callback, void *user_data)
 849 {
 850         client_cb.p2p_detached_cb = callback;
 851         client_cb.p2p_detached_ud = user_data;
 852 }
 853
 854 void net_nfc_neard_unset_p2p_detached(void)
 855 {
 856         client_cb.p2p_detached_cb = NULL;
 857         client_cb.p2p_detached_ud = NULL;
 858 }
 859
 860 void net_nfc_neard_set_p2p_data_received(
 861                 net_nfc_client_p2p_data_received callback, void *user_data)
 862 {
 863         client_cb.p2p_data_received_cb = callback;
 864         client_cb.p2p_data_received_ud = user_data;
 865 }
 866
 867 void net_nfc_neard_unset_p2p_data_received(void)
 868 {
 869         client_cb.p2p_data_received_cb = NULL;
 870         client_cb.p2p_data_received_ud = NULL;
 871 }
 872
 873 void net_nfc_neard_set_tag_discovered(
 874                 net_nfc_client_tag_tag_discovered callback, void *user_data)
 875 {
 876         client_cb.tag_discovered_cb = callback;
 877         client_cb.tag_discovered_ud = user_data;
 878 }
 879
 880 void net_nfc_neard_unset_tag_discovered(void)
 881 {
 882         client_cb.tag_discovered_cb = NULL;
 883         client_cb.tag_discovered_ud = NULL;
 884 }
 885
 886 void net_nfc_neard_set_tag_detached(
 887                 net_nfc_client_tag_tag_detached callback, void *user_data)
 888 {
 889         client_cb.tag_detached_cb = callback;
 890         client_cb.tag_detached_ud = user_data;
 891 }
 892
 893 void net_nfc_neard_unset_tag_detached(void)
 894 {
 895         client_cb.tag_detached_cb = NULL;
 896         client_cb.tag_detached_ud = NULL;
 897 }
 898
 899 void net_nfc_neard_set_activated(net_nfc_client_manager_activated callback,
 900                 void *user_data)
 901 {
 902         client_cb.activated_cb = callback;
 903         client_cb.activated_ud = user_data;
 904 }
 905
 906 void net_nfc_neard_unset_activated(void)
 907 {
 908         client_cb.activated_cb = NULL;
 909         client_cb.activated_ud = NULL;
 910 }
 911
 912 net_nfc_error_e net_nfc_neard_cb_init(void)
 913 {
 914         if (neardal_set_cb_adapter_added(
 915                 _adapter_added_cb, NULL) != NEARDAL_SUCCESS ||
 916                 neardal_set_cb_adapter_removed(
 917                         _adapter_removed_cb, NULL) != NEARDAL_SUCCESS ||
 918                 neardal_set_cb_adapter_property_changed(
 919                         _adapter_property_changed_cb, NULL) != NEARDAL_SUCCESS ||
 920                 neardal_set_cb_power_completed(_power_completed_cb, NULL)
 921                                                         != NEARDAL_SUCCESS ||
 922                 neardal_set_cb_tag_found(
 923                         _tag_found_cb, NULL) != NEARDAL_SUCCESS ||
 924                 neardal_set_cb_tag_lost(
 925                         _tag_lost_cb, NULL) != NEARDAL_SUCCESS ||
 926                 neardal_set_cb_read_completed(_read_completed_cb, NULL)
 927                                                         != NEARDAL_SUCCESS ||
 928                 neardal_set_cb_write_completed(_write_completed_cb, NULL)
 929                                                         != NEARDAL_SUCCESS ||
 930                 neardal_set_cb_dev_found(_device_found_cb, NULL)
 931                                                         != NEARDAL_SUCCESS ||
 932                 neardal_set_cb_dev_lost(_device_lost_cb, NULL)
 933                                                         != NEARDAL_SUCCESS ||
 934                 neardal_set_cb_push_completed(_p2p_send_completed_cb, NULL)
 935                                                         != NEARDAL_SUCCESS ||
 936                 neardal_set_cb_p2p_received(_p2p_received_cb, NULL)
 937                                                         != NEARDAL_SUCCESS) {
 938
 939                 NFC_DBG("failed to register the callback");
 940
 941                 return NET_NFC_NOT_REGISTERED;
 942         }
 943
 944         return NET_NFC_OK;
 945 }
 946
 947 net_nfc_error_e net_nfc_neard_initialize(void)
 948 {
 949         errorCode_t err;
 950         int len;
 951         neardal_adapter *neard_adapter = NULL;
 952         char **adapters = NULL;
 953
 954         NFC_DBG("neard init");
 955
 956         if (nfc_adapter_path != NULL)
 957                 return NET_NFC_OK;
 958
 959         net_nfc_neard_cb_init();
 960
 961         err = neardal_get_adapters(&adapters, &len);
 962         NFC_DBG("failed to get adapter error: %d", err);
 963         if (err != NEARDAL_SUCCESS)
 964                 goto out_err;
 965
 966         if (!(len > 0 && adapters != NULL))
 967                 goto out_err;
 968
 969         nfc_adapter_path = g_strdup(adapters[0]);
 970         NFC_DBG("adapter_path: %s", nfc_adapter_path);
 971
 972         neardal_free_array(&adapters);
 973         adapters = NULL;
 974
 975         err = neardal_get_adapter_properties(nfc_adapter_path, &neard_adapter);
 976         if (err != NEARDAL_SUCCESS)
 977                 goto out_err;
 978
 979         if (neard_adapter == NULL)
 980                 goto out_err;
 981
 982         nfc_adapter_powered = (neard_adapter->powered) ? true : false;
 983         nfc_adapter_polling = (neard_adapter->polling) ? true : false;
 984         neardal_free_adapter(neard_adapter);
 985         neard_adapter = NULL;
 986
 987         NFC_DBG("adapter powered %d, polling %d", nfc_adapter_powered,
 988                                                         nfc_adapter_polling);
 989
 990         if (vconf_set_bool(VCONFKEY_NFC_STATE, nfc_adapter_powered) != 0)
 991                 NFC_DBG("vconf NFC state set failed ");
 992         if (nfc_adapter_powered == TRUE && nfc_adapter_polling == false)
 993                 neardal_start_poll_loop(nfc_adapter_path, NEARD_ADP_MODE_DUAL);
 994
 995         return NET_NFC_OK;
 996
 997 out_err:
 998         if (adapters)
 999                 neardal_free_array(&adapters);
1000
1001         if (neard_adapter)
1002                 neardal_free_adapter(neard_adapter);
1003
1004         return NET_NFC_OPERATION_FAIL;
1005 }
1006
1007 void net_nfc_neard_deinitialize(void)
1008 {
1009         NFC_DBG("neard deinitialize");
1010
1011         if (nfc_adapter_mode) {
1012                 g_free(nfc_adapter_mode);
1013                 nfc_adapter_mode = NULL;
1014         }
1015
1016         if (tag != NULL) {
1017                 neardal_free_tag(tag);
1018                 tag = NULL;
1019         }
1020
1021         if (dev != NULL) {
1022                 neardal_free_device(dev);
1023                 dev = NULL;
1024         }
1025
1026         if (rawNDEF != NULL) {
1027                 net_nfc_util_free_data(rawNDEF);
1028                 rawNDEF = NULL;
1029         }
1030
1031         if (target_handle != NULL) {
1032                 g_free(target_handle);
1033                 target_handle = NULL;
1034         }
1035
1036         if (target_info != NULL) {
1037                 g_free(target_info);
1038                 target_info = NULL;
1039         }
1040
1041         if (handover_info != NULL) {
1042                 g_free(handover_info);
1043                 handover_info = NULL;
1044         }
1045 }