src/net_nfc_client_test.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_debug_internal.h"
  18 #include "net_nfc_util_gdbus_internal.h"
  19 #include "net_nfc_gdbus.h"
  20 #include "net_nfc_client.h"
  21 #include "net_nfc_client_util_internal.h"
  22 #include "net_nfc_client_manager.h"
  23 #include "net_nfc_client_test.h"
  24
  25 #ifndef NET_NFC_EXPORT_API
  26 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  27 #endif
  28
  29 static void test_call_sim_test_callback(GObject *source_object,
  30                                         GAsyncResult *res,
  31                                         gpointer user_data);
  32
  33 static void test_call_prbs_test_callback(GObject *source_object,
  34                                         GAsyncResult *res,
  35                                         gpointer user_data);
  36
  37 static void test_call_get_firmware_version_callback(GObject *source_object,
  38                                                 GAsyncResult *res,
  39                                                 gpointer user_data);
  40
  41 static void test_call_set_ee_data_callback(GObject *source_object,
  42                                         GAsyncResult *res,
  43                                         gpointer user_data);
  44
  45 static void test_call_ese_test_callback(GObject *source_object,
  46                                         GAsyncResult *res,
  47                                         gpointer user_data);
  48
  49 static NetNfcGDbusTest *test_proxy = NULL;
  50
  51
  52 static void test_call_sim_test_callback(GObject *source_object,
  53                                         GAsyncResult *res,
  54                                         gpointer user_data)
  55 {
  56         NetNfcCallback *func_data = (NetNfcCallback *)user_data;
  57         net_nfc_error_e out_result;
  58         GError *error = NULL;
  59
  60         g_assert(user_data != NULL);
  61
  62         if (net_nfc_gdbus_test_call_sim_test_finish(
  63                                 NET_NFC_GDBUS_TEST(source_object),
  64                                 (gint *)&out_result,
  65                                 res,
  66                                 &error) == FALSE)
  67         {
  68                 DEBUG_ERR_MSG("Can not finish sim_test: %s",
  69                         error->message);
  70                 out_result = NET_NFC_IPC_FAIL;
  71
  72                 g_error_free(error);
  73         }
  74
  75         if (func_data->callback != NULL)
  76         {
  77                 net_nfc_client_test_sim_test_completed callback =
  78                         (net_nfc_client_test_sim_test_completed)func_data->callback;
  79
  80                 callback(out_result, func_data->user_data);
  81         }
  82
  83         g_free(func_data);
  84 }
  85
  86 static void test_call_prbs_test_callback(GObject *source_object,
  87                                         GAsyncResult *res,
  88                                         gpointer user_data)
  89 {
  90         NetNfcCallback *func_data = (NetNfcCallback *)user_data;
  91         net_nfc_error_e out_result;
  92         GError *error = NULL;
  93
  94         g_assert(user_data != NULL);
  95
  96         if (net_nfc_gdbus_test_call_prbs_test_finish(
  97                                 NET_NFC_GDBUS_TEST(source_object),
  98                                 (gint *)&out_result,
  99                                 res,
 100                                 &error) == FALSE)
 101         {
 102                 DEBUG_ERR_MSG("Can not finish prbs test: %s",
 103                         error->message);
 104                 out_result = NET_NFC_IPC_FAIL;
 105
 106                 g_error_free(error);
 107         }
 108
 109         if (func_data->callback != NULL)
 110         {
 111                 net_nfc_client_test_prbs_test_completed callback =
 112                         (net_nfc_client_test_prbs_test_completed)func_data->callback;
 113
 114                 callback(out_result, func_data->user_data);
 115         }
 116
 117         g_free(func_data);
 118 }
 119
 120 static void test_call_get_firmware_version_callback(GObject *source_object,
 121                                                 GAsyncResult *res,
 122                                                 gpointer user_data)
 123 {
 124         NetNfcCallback *func_data = (NetNfcCallback *)user_data;
 125         net_nfc_error_e out_result;
 126         gchar *out_version = NULL;
 127         GError *error = NULL;
 128
 129         g_assert(user_data != NULL);
 130
 131         if (net_nfc_gdbus_test_call_get_firmware_version_finish(
 132                                 NET_NFC_GDBUS_TEST(source_object),
 133                                 (gint *)&out_result,
 134                                 &out_version,
 135                                 res,
 136                                 &error) == FALSE)
 137         {
 138                 DEBUG_ERR_MSG("Can not finish get_firmware_version: %s",
 139                         error->message);
 140                 out_result = NET_NFC_IPC_FAIL;
 141
 142                 g_error_free(error);
 143         }
 144
 145         if (func_data->callback != NULL)
 146         {
 147                 net_nfc_client_test_get_firmware_version_completed callback =
 148                         (net_nfc_client_test_get_firmware_version_completed)func_data->callback;
 149
 150                 callback(out_result, out_version, func_data->user_data);
 151         }
 152
 153         g_free(out_version);
 154         g_free(func_data);
 155 }
 156
 157 static void test_call_set_ee_data_callback(GObject *source_object,
 158                                         GAsyncResult *res,
 159                                         gpointer user_data)
 160 {
 161         NetNfcCallback *func_data = (NetNfcCallback *)user_data;
 162         net_nfc_error_e out_result;
 163         GError *error = NULL;
 164
 165         g_assert(user_data != NULL);
 166
 167         if (net_nfc_gdbus_test_call_set_ee_data_finish(
 168                                 NET_NFC_GDBUS_TEST(source_object),
 169                                 (gint *)&out_result,
 170                                 res,
 171                                 &error) == FALSE)
 172         {
 173                 DEBUG_ERR_MSG("Can not finish set_ee_data: %s",
 174                         error->message);
 175                 out_result = NET_NFC_IPC_FAIL;
 176
 177                 g_error_free(error);
 178         }
 179
 180         if (func_data->callback != NULL)
 181         {
 182                 net_nfc_client_test_set_ee_data_completed callback =
 183                         (net_nfc_client_test_set_ee_data_completed)func_data->callback;
 184
 185                 callback(out_result, func_data->user_data);
 186         }
 187
 188         g_free(func_data);
 189 }
 190
 191 static void test_call_ese_test_callback(GObject *source_object,
 192                                         GAsyncResult *res,
 193                                         gpointer user_data)
 194 {
 195         NetNfcCallback *func_data = (NetNfcCallback *)user_data;
 196         net_nfc_error_e out_result;
 197         GError *error = NULL;
 198
 199         g_assert(user_data != NULL);
 200
 201         if (net_nfc_gdbus_test_call_ese_test_finish(
 202                                 NET_NFC_GDBUS_TEST(source_object),
 203                                 (gint *)&out_result,
 204                                 res,
 205                                 &error) == FALSE)
 206         {
 207                 DEBUG_ERR_MSG("Can not finish sim_test: %s",
 208                         error->message);
 209                 out_result = NET_NFC_IPC_FAIL;
 210
 211                 g_error_free(error);
 212         }
 213
 214         if (func_data->callback != NULL)
 215         {
 216                 net_nfc_client_test_ese_test_completed callback =
 217                         (net_nfc_client_test_ese_test_completed)func_data->callback;
 218
 219                 callback(out_result, func_data->user_data);
 220         }
 221
 222         g_free(func_data);
 223 }
 224
 225
 226 NET_NFC_EXPORT_API
 227 net_nfc_error_e net_nfc_client_test_sim_test(
 228                         net_nfc_client_test_sim_test_completed callback,
 229                         void *user_data)
 230 {
 231         NetNfcCallback *func_data;
 232
 233         if (test_proxy == NULL)
 234         {
 235                 if(net_nfc_client_test_init() != NET_NFC_OK)
 236                 {
 237                         DEBUG_ERR_MSG("test_proxy fail");
 238                         return NET_NFC_NOT_INITIALIZED;
 239                 }
 240         }
 241
 242         /* prevent executing daemon when nfc is off */
 243         if (net_nfc_client_manager_is_activated() == false) {
 244                 return NET_NFC_NOT_ACTIVATED;
 245         }
 246
 247         func_data = g_try_new0(NetNfcCallback, 1);
 248         if (func_data == NULL)
 249                 return NET_NFC_ALLOC_FAIL;
 250
 251         func_data->callback = (gpointer)callback;
 252         func_data->user_data = user_data;
 253
 254         net_nfc_gdbus_test_call_sim_test(test_proxy,
 255                                         NULL,
 256                                         test_call_sim_test_callback,
 257                                         func_data);
 258
 259         return NET_NFC_OK;
 260 }
 261
 262 NET_NFC_EXPORT_API
 263 net_nfc_error_e net_nfc_client_test_sim_test_sync(void)
 264 {
 265         net_nfc_error_e out_result = NET_NFC_OK;
 266         GError *error = NULL;
 267
 268         if (test_proxy == NULL)
 269         {
 270                 if(net_nfc_client_test_init() != NET_NFC_OK)
 271                 {
 272                         DEBUG_ERR_MSG("test_proxy fail");
 273                         return NET_NFC_NOT_INITIALIZED;
 274                 }
 275         }
 276
 277         /* prevent executing daemon when nfc is off */
 278         if (net_nfc_client_manager_is_activated() == false) {
 279                 return NET_NFC_NOT_ACTIVATED;
 280         }
 281
 282         if (net_nfc_gdbus_test_call_sim_test_sync(test_proxy,
 283                                         (gint *)&out_result,
 284                                         NULL,
 285                                         &error) == FALSE)
 286         {
 287                 DEBUG_ERR_MSG("can not call SimTest: %s",
 288                                 error->message);
 289                 out_result = NET_NFC_IPC_FAIL;
 290
 291                 g_error_free(error);
 292         }
 293
 294         return out_result;
 295 }
 296
 297 NET_NFC_EXPORT_API
 298 net_nfc_error_e net_nfc_client_test_prbs_test(uint32_t tech,
 299                         uint32_t rate,
 300                         net_nfc_client_test_prbs_test_completed callback,
 301                         void *user_data)
 302 {
 303         NetNfcCallback *func_data;
 304
 305         if (test_proxy == NULL)
 306         {
 307                 if(net_nfc_client_test_init() != NET_NFC_OK)
 308                 {
 309                         DEBUG_ERR_MSG("test_proxy fail");
 310                         return NET_NFC_NOT_INITIALIZED;
 311                 }
 312         }
 313
 314         /* prevent executing daemon when nfc is off */
 315         if (net_nfc_client_manager_is_activated() == false) {
 316                 return NET_NFC_NOT_ACTIVATED;
 317         }
 318
 319         func_data = g_try_new0(NetNfcCallback, 1);
 320         if (func_data == NULL)
 321                 return NET_NFC_ALLOC_FAIL;
 322
 323         func_data->callback = (gpointer)callback;
 324         func_data->user_data = user_data;
 325
 326         net_nfc_gdbus_test_call_prbs_test(test_proxy,
 327                                         tech,
 328                                         rate,
 329                                         NULL,
 330                                         test_call_prbs_test_callback,
 331                                         func_data);
 332
 333         return NET_NFC_OK;
 334 }
 335
 336 NET_NFC_EXPORT_API
 337 net_nfc_error_e net_nfc_client_test_prbs_test_sync(uint32_t tech,
 338                                                 uint32_t rate)
 339 {
 340         net_nfc_error_e out_result = NET_NFC_OK;
 341         GError *error = NULL;
 342
 343         if (test_proxy == NULL)
 344         {
 345                 if(net_nfc_client_test_init() != NET_NFC_OK)
 346                 {
 347                         DEBUG_ERR_MSG("test_proxy fail");
 348                         return NET_NFC_NOT_INITIALIZED;
 349                 }
 350         }
 351
 352         /* prevent executing daemon when nfc is off */
 353         if (net_nfc_client_manager_is_activated() == false) {
 354                 return NET_NFC_NOT_ACTIVATED;
 355         }
 356
 357         if (net_nfc_gdbus_test_call_prbs_test_sync(test_proxy,
 358                                         tech,
 359                                         rate,
 360                                         (gint *)&out_result,
 361                                         NULL,
 362                                         &error) == FALSE)
 363         {
 364                 DEBUG_ERR_MSG("can not call PrbsTest: %s",
 365                                 error->message);
 366                 out_result = NET_NFC_IPC_FAIL;
 367
 368                 g_error_free(error);
 369         }
 370
 371         return out_result;
 372 }
 373
 374 NET_NFC_EXPORT_API
 375 net_nfc_error_e net_nfc_client_test_get_firmware_version(
 376                 net_nfc_client_test_get_firmware_version_completed callback,
 377                 void *user_data)
 378 {
 379         NetNfcCallback *func_data;
 380
 381         if (test_proxy == NULL)
 382         {
 383                 if(net_nfc_client_test_init() != NET_NFC_OK)
 384                 {
 385                         DEBUG_ERR_MSG("test_proxy fail");
 386                         return NET_NFC_NOT_INITIALIZED;
 387                 }
 388         }
 389
 390         /* prevent executing daemon when nfc is off */
 391         if (net_nfc_client_manager_is_activated() == false) {
 392                 return NET_NFC_NOT_ACTIVATED;
 393         }
 394
 395         func_data = g_try_new0(NetNfcCallback, 1);
 396         if (func_data == NULL)
 397                 return NET_NFC_ALLOC_FAIL;
 398
 399         func_data->callback = (gpointer)callback;
 400         func_data->user_data = user_data;
 401
 402         net_nfc_gdbus_test_call_get_firmware_version(test_proxy,
 403                                 NULL,
 404                                 test_call_get_firmware_version_callback,
 405                                 func_data);
 406
 407         return NET_NFC_OK;
 408 }
 409
 410 NET_NFC_EXPORT_API
 411 net_nfc_error_e net_nfc_client_test_get_firmware_version_sync(char **version)
 412 {
 413         net_nfc_error_e out_result = NET_NFC_OK;
 414         gchar *out_version = NULL;
 415         GError *error = NULL;
 416
 417         if (version == NULL)
 418                 return NET_NFC_NULL_PARAMETER;
 419
 420         *version = NULL;
 421
 422         if (test_proxy == NULL)
 423         {
 424                 if(net_nfc_client_test_init() != NET_NFC_OK)
 425                 {
 426                         DEBUG_ERR_MSG("test_proxy fail");
 427                         return NET_NFC_NOT_INITIALIZED;
 428                 }
 429         }
 430
 431         /* prevent executing daemon when nfc is off */
 432         if (net_nfc_client_manager_is_activated() == false) {
 433                 return NET_NFC_NOT_ACTIVATED;
 434         }
 435
 436         if (net_nfc_gdbus_test_call_get_firmware_version_sync(test_proxy,
 437                                         (gint *)&out_result,
 438                                         &out_version,
 439                                         NULL,
 440                                         &error) == TRUE)
 441         {
 442                 *version = out_version;
 443         }
 444         else
 445         {
 446                 DEBUG_ERR_MSG("can not call Get Firmware version: %s",
 447                                 error->message);
 448                 out_result = NET_NFC_IPC_FAIL;
 449
 450                 g_error_free(error);
 451         }
 452
 453         return out_result;
 454 }
 455
 456 NET_NFC_EXPORT_API
 457 net_nfc_error_e net_nfc_client_test_set_ee_data(int mode,
 458                         int reg_id,
 459                         data_h data,
 460                         net_nfc_client_test_set_ee_data_completed callback,
 461                         void *user_data)
 462 {
 463         NetNfcCallback *func_data;
 464         GVariant *variant;
 465
 466         if (test_proxy == NULL)
 467         {
 468                 if(net_nfc_client_test_init() != NET_NFC_OK)
 469                 {
 470                         DEBUG_ERR_MSG("test_proxy fail");
 471                         return NET_NFC_NOT_INITIALIZED;
 472                 }
 473         }
 474
 475         /* prevent executing daemon when nfc is off */
 476         if (net_nfc_client_manager_is_activated() == false) {
 477                 return NET_NFC_NOT_ACTIVATED;
 478         }
 479
 480         func_data = g_try_new0(NetNfcCallback, 1);
 481         if (func_data == NULL) {
 482                 return NET_NFC_ALLOC_FAIL;
 483         }
 484
 485         func_data->callback = (gpointer)callback;
 486         func_data->user_data = user_data;
 487
 488         variant = net_nfc_util_gdbus_data_to_variant((data_s *)data);
 489
 490         net_nfc_gdbus_test_call_set_ee_data(test_proxy,
 491                                         mode,
 492                                         reg_id,
 493                                         variant,
 494                                         NULL,
 495                                         test_call_set_ee_data_callback,
 496                                         func_data);
 497
 498         return NET_NFC_OK;
 499 }
 500
 501 NET_NFC_EXPORT_API
 502 net_nfc_error_e net_nfc_client_test_set_ee_data_sync(int mode,
 503                                                 int reg_id,
 504                                                 data_h data)
 505 {
 506         net_nfc_error_e out_result = NET_NFC_OK;
 507         GVariant *variant = NULL;
 508         GError *error = NULL;
 509
 510         if (test_proxy == NULL)
 511         {
 512                 if(net_nfc_client_test_init() != NET_NFC_OK)
 513                 {
 514                         DEBUG_ERR_MSG("test_proxy fail");
 515                         return NET_NFC_NOT_INITIALIZED;
 516                 }
 517         }
 518
 519         /* prevent executing daemon when nfc is off */
 520         if (net_nfc_client_manager_is_activated() == false) {
 521                 return NET_NFC_NOT_ACTIVATED;
 522         }
 523
 524         variant = net_nfc_util_gdbus_data_to_variant((data_s *)data);
 525
 526         if (net_nfc_gdbus_test_call_set_ee_data_sync(test_proxy,
 527                                         mode,
 528                                         reg_id,
 529                                         variant,
 530                                         (gint *)&out_result,
 531                                         NULL,
 532                                         &error) == FALSE)
 533         {
 534                 DEBUG_ERR_MSG("can not call SetEeTest: %s",
 535                                 error->message);
 536                 out_result = NET_NFC_IPC_FAIL;
 537
 538                 g_error_free(error);
 539         }
 540
 541         return out_result;
 542 }
 543
 544 NET_NFC_EXPORT_API
 545 net_nfc_error_e net_nfc_client_test_ese_test(
 546                         net_nfc_client_test_ese_test_completed callback,
 547                         void *user_data)
 548 {
 549         NetNfcCallback *func_data;
 550
 551         DEBUG_CLIENT_MSG("NFC ESE Test!!!!");
 552
 553         if (test_proxy == NULL)
 554         {
 555                 if(net_nfc_client_test_init() != NET_NFC_OK)
 556                 {
 557                         DEBUG_ERR_MSG("test_proxy fail");
 558                         return NET_NFC_NOT_INITIALIZED;
 559                 }
 560         }
 561
 562         /* prevent executing daemon when nfc is off */
 563         if (net_nfc_client_manager_is_activated() == false) {
 564                 return NET_NFC_NOT_ACTIVATED;
 565         }
 566
 567         func_data = g_try_new0(NetNfcCallback, 1);
 568         if (func_data == NULL)
 569                 return NET_NFC_ALLOC_FAIL;
 570
 571         func_data->callback = (gpointer)callback;
 572         func_data->user_data = user_data;
 573
 574         net_nfc_gdbus_test_call_ese_test(test_proxy,
 575                                         NULL,
 576                                         test_call_ese_test_callback,
 577                                         func_data);
 578
 579         return NET_NFC_OK;
 580 }
 581
 582 NET_NFC_EXPORT_API
 583 net_nfc_error_e net_nfc_client_test_ese_test_sync(void)
 584 {
 585         net_nfc_error_e out_result = NET_NFC_OK;
 586         GError *error = NULL;
 587
 588         DEBUG_CLIENT_MSG("NFC ESE Test SYNC!!!!");
 589
 590         if (test_proxy == NULL)
 591         {
 592                 if(net_nfc_client_test_init() != NET_NFC_OK)
 593                 {
 594                         DEBUG_ERR_MSG("test_proxy fail");
 595                         return NET_NFC_NOT_INITIALIZED;
 596                 }
 597         }
 598
 599         /* prevent executing daemon when nfc is off */
 600         if (net_nfc_client_manager_is_activated() == false) {
 601                 return NET_NFC_NOT_ACTIVATED;
 602         }
 603
 604         if (net_nfc_gdbus_test_call_ese_test_sync(test_proxy,
 605                                         (gint *)&out_result,
 606                                         NULL,
 607                                         &error) == FALSE)
 608         {
 609                 DEBUG_ERR_MSG("can not call ESE Test: %s",
 610                                 error->message);
 611                 out_result = NET_NFC_IPC_FAIL;
 612
 613                 g_error_free(error);
 614         }
 615
 616         return out_result;
 617 }
 618
 619 NET_NFC_EXPORT_API
 620 net_nfc_error_e net_nfc_client_test_set_se_tech_type_sync(
 621         net_nfc_se_type_e type, int tech)
 622 {
 623         net_nfc_error_e out_result = NET_NFC_OK;
 624         GError *error = NULL;
 625
 626         if (test_proxy == NULL)
 627         {
 628                 if(net_nfc_client_test_init() != NET_NFC_OK)
 629                 {
 630                         DEBUG_ERR_MSG("test_proxy fail");
 631                         return NET_NFC_NOT_INITIALIZED;
 632                 }
 633         }
 634
 635         /* prevent executing daemon when nfc is off */
 636         if (net_nfc_client_manager_is_activated() == false) {
 637                 return NET_NFC_NOT_ACTIVATED;
 638         }
 639
 640         if (net_nfc_gdbus_test_call_set_se_tech_type_sync(test_proxy,
 641                                         (guint32)type,
 642                                         (guint32)tech,
 643                                         (gint *)&out_result,
 644                                         NULL,
 645                                         &error) == FALSE)
 646         {
 647                 DEBUG_ERR_MSG("can not call SetSeTechType: %s",
 648                                 error->message);
 649                 out_result = NET_NFC_IPC_FAIL;
 650
 651                 g_error_free(error);
 652         }
 653
 654         return out_result;
 655 }
 656
 657 NET_NFC_EXPORT_API
 658 net_nfc_error_e net_nfc_client_test_set_listen_tech_mask_sync(uint32_t tech)
 659 {
 660         net_nfc_error_e result = NET_NFC_OK;
 661         GError *error = NULL;
 662
 663         DEBUG_CLIENT_MSG("net_nfc_client_test_set_listen_tech_mask_sync start");
 664
 665         if (test_proxy == NULL)
 666         {
 667                 if(net_nfc_client_test_init() != NET_NFC_OK)
 668                 {
 669                         DEBUG_ERR_MSG("test_proxy fail");
 670                         return NET_NFC_NOT_INITIALIZED;
 671                 }
 672         }
 673
 674         /* prevent executing daemon when nfc is off */
 675         if (net_nfc_client_manager_is_activated() == false) {
 676                 return NET_NFC_NOT_ACTIVATED;
 677         }
 678
 679         if (net_nfc_gdbus_test_call_set_listen_tech_mask_sync(test_proxy,
 680                                         tech,
 681                                         &result,
 682                                         NULL,
 683                                         &error) == FALSE)
 684         {
 685                 DEBUG_ERR_MSG("can not call listen tech mask: %s",
 686                                 error->message);
 687                 result = NET_NFC_IPC_FAIL;
 688
 689                 g_error_free(error);
 690         }
 691
 692         return result;
 693 }
 694
 695
 696 net_nfc_error_e net_nfc_client_test_init(void)
 697 {
 698         GError *error = NULL;
 699
 700         if (test_proxy)
 701         {
 702                 DEBUG_CLIENT_MSG("Already initialized");
 703
 704                 return NET_NFC_OK;
 705         }
 706
 707         test_proxy = net_nfc_gdbus_test_proxy_new_for_bus_sync(
 708                                         G_BUS_TYPE_SYSTEM,
 709                                         G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
 710                                         "org.tizen.NetNfcService",
 711                                         "/org/tizen/NetNfcService/Test",
 712                                         NULL,
 713                                         &error);
 714         if (test_proxy == NULL)
 715         {
 716                 DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
 717                 g_error_free(error);
 718
 719                 return NET_NFC_UNKNOWN_ERROR;
 720         }
 721
 722         return NET_NFC_OK;
 723 }
 724
 725 void net_nfc_client_test_deinit(void)
 726 {
 727         if (test_proxy)
 728         {
 729                 g_object_unref(test_proxy);
 730                 test_proxy = NULL;
 731         }
 732 }