client/net_nfc_client_ndef.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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_data.h"
  24 #include "net_nfc_ndef_message.h"
  25 #include "net_nfc_client.h"
  26 #include "net_nfc_client_manager.h"
  27 #include "net_nfc_client_ndef.h"
  28 #include "net_nfc_client_tag_internal.h"
  29 #include "net_nfc_neard.h"
  30
  31 static NetNfcGDbusNdef *ndef_proxy = NULL;
  32
  33 static gboolean ndef_is_supported_tag(void)
  34 {
  35         net_nfc_target_info_s *target_info = NULL;
  36
  37         target_info = net_nfc_client_tag_get_client_target_info();
  38         if (NULL == target_info)
  39         {
  40                 NFC_ERR("target_info does not exist");
  41                 return FALSE;
  42         }
  43
  44         switch (target_info->devType)
  45         {
  46         case NET_NFC_ISO14443_A_PICC :
  47         case NET_NFC_MIFARE_MINI_PICC :
  48         case NET_NFC_MIFARE_1K_PICC :
  49         case NET_NFC_MIFARE_4K_PICC :
  50         case NET_NFC_MIFARE_ULTRA_PICC :
  51         case NET_NFC_JEWEL_PICC :
  52                 return TRUE;
  53                 break;
  54         default:
  55                 NFC_ERR("not supported tag(%d) for read only tag", target_info->devType);
  56                 return FALSE;
  57         }
  58 }
  59
  60 static void ndef_call_make_read_only(GObject *source_object,
  61                 GAsyncResult *res, gpointer user_data)
  62 {
  63         gboolean ret;
  64         GError *error = NULL;
  65         net_nfc_error_e out_result;
  66         NetNfcCallback *func_data = user_data;
  67         net_nfc_client_ndef_make_read_only_completed callback;
  68
  69         g_assert(user_data != NULL);
  70
  71         ret = net_nfc_gdbus_ndef_call_make_read_only_finish(NET_NFC_GDBUS_NDEF(source_object),
  72                         (gint *)&out_result, res, &error);
  73
  74         if (FALSE == ret)
  75         {
  76                 NFC_ERR("Can not finish make read only: %s", error->message);
  77                 g_error_free(error);
  78
  79                 out_result = NET_NFC_IPC_FAIL;
  80         }
  81
  82         if (func_data->callback != NULL)
  83         {
  84                 callback = (net_nfc_client_ndef_make_read_only_completed)func_data->callback;
  85
  86                 callback(out_result, func_data->user_data);
  87         }
  88
  89         g_free(func_data);
  90 }
  91
  92 static void ndef_call_format(GObject *source_object,
  93                 GAsyncResult *res, gpointer user_data)
  94 {
  95         gboolean ret;
  96         GError *error = NULL;
  97         net_nfc_error_e out_result;
  98         NetNfcCallback *func_data = user_data;
  99         net_nfc_client_ndef_format_completed callback;
 100
 101         g_assert(user_data != NULL);
 102
 103         ret = net_nfc_gdbus_ndef_call_format_finish(NET_NFC_GDBUS_NDEF(source_object),
 104                                 (gint *)&out_result, res, &error);
 105
 106         if (FALSE == ret)
 107         {
 108                 NFC_ERR("Can not finish format: %s", error->message);
 109                 g_error_free(error);
 110
 111                 out_result = NET_NFC_IPC_FAIL;
 112         }
 113
 114         if (func_data->callback != NULL)
 115         {
 116                 callback = (net_nfc_client_ndef_format_completed)func_data->callback;
 117
 118                 callback(out_result, func_data->user_data);
 119         }
 120
 121         g_free(func_data);
 122 }
 123
 124 API net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_s *handle,
 125                 net_nfc_client_ndef_read_completed callback, void *user_data)
 126 {
 127         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 128
 129         /* prevent executing daemon when nfc is off */
 130         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 131         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 132
 133         NFC_DBG("send request :: read ndef = [%p]", handle);
 134
 135         return net_nfc_neard_read_tag(handle, callback, user_data);
 136 }
 137
 138 API net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_s *handle,
 139                 ndef_message_s **message)
 140 {
 141         gboolean ret;
 142         GError *error = NULL;
 143         GVariant *out_data = NULL;
 144         net_nfc_error_e out_result = NET_NFC_OK;
 145
 146         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 147         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 148
 149         /* prevent executing daemon when nfc is off */
 150         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 151         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 152
 153         NFC_DBG("send request :: read ndef = [%p]", handle);
 154
 155         ret = net_nfc_gdbus_ndef_call_read_sync(ndef_proxy,
 156                         GPOINTER_TO_UINT(handle),
 157                         net_nfc_client_gdbus_get_privilege(),
 158                         (gint *)&out_result,
 159                         &out_data,
 160                         NULL,
 161                         &error);
 162
 163         if (TRUE == ret)
 164         {
 165                 *message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
 166         }
 167         else
 168         {
 169                 NFC_ERR("can not call read: %s", error->message);
 170                 g_error_free(error);
 171                 out_result = NET_NFC_IPC_FAIL;
 172         }
 173
 174         return out_result;
 175 }
 176
 177 API net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_s *handle,
 178                 ndef_message_s *message,
 179                 net_nfc_client_ndef_write_completed callback,
 180                 void *user_data)
 181 {
 182         size_t length;
 183         net_nfc_error_e ret;
 184         data_s data = {NULL, 0};
 185
 186         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 187         RETV_IF(NULL == message, NET_NFC_NULL_PARAMETER);
 188
 189         /* prevent executing daemon when nfc is off */
 190         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 191         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 192
 193         length = net_nfc_util_get_ndef_message_length((ndef_message_s *)message);
 194         if (length > 0) {
 195                 if (net_nfc_util_alloc_data(&data, length) == true) {
 196                         ret = net_nfc_util_convert_ndef_message_to_rawdata((ndef_message_s *)message,
 197                                                 &data);
 198                         if (NET_NFC_OK != ret) {
 199                                 NFC_ERR("can not convert ndef_message to rawdata");
 200
 201                                 net_nfc_util_free_data(&data);
 202                         }
 203                 } else {
 204                         NFC_ERR("net_nfc_util_alloc_data failed");
 205
 206                         return NET_NFC_ALLOC_FAIL;
 207                 }
 208         } else {
 209                 NFC_ERR("message length is 0");
 210
 211                 return NET_NFC_INVALID_PARAM;
 212         }
 213
 214         ret = net_nfc_neard_write_ndef(handle, &data, callback, user_data);
 215
 216         net_nfc_util_free_data(&data);
 217
 218         return ret;
 219 }
 220
 221 API net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_s *handle,
 222                 ndef_message_s *message)
 223 {
 224         gboolean ret;
 225         GVariant *arg_data;
 226         GError *error = NULL;
 227         net_nfc_error_e out_result = NET_NFC_OK;
 228
 229         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 230         RETV_IF(NULL == message, NET_NFC_NULL_PARAMETER);
 231
 232         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 233
 234         /* prevent executing daemon when nfc is off */
 235         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 236         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 237
 238         arg_data = net_nfc_util_gdbus_ndef_message_to_variant(message);
 239
 240         ret = net_nfc_gdbus_ndef_call_write_sync(ndef_proxy ,
 241                         GPOINTER_TO_UINT(handle),
 242                         arg_data,
 243                         net_nfc_client_gdbus_get_privilege(),
 244                         (gint *)&out_result,
 245                         NULL,
 246                         &error);
 247
 248         if (FALSE == ret)
 249         {
 250                 NFC_ERR("can not call write: %s", error->message);
 251                 g_error_free(error);
 252                 out_result = NET_NFC_IPC_FAIL;
 253         }
 254
 255         return out_result;
 256 }
 257
 258 API net_nfc_error_e net_nfc_client_ndef_make_read_only(
 259                 net_nfc_target_handle_s *handle,
 260                 net_nfc_client_ndef_make_read_only_completed callback,
 261                 void *user_data)
 262 {
 263         NetNfcCallback *func_data;
 264
 265         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 266         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 267
 268         /* prevent executing daemon when nfc is off */
 269         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 270         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 271         RETV_IF(ndef_is_supported_tag() == FALSE, NET_NFC_NOT_SUPPORTED);
 272
 273         func_data = g_try_new0(NetNfcCallback, 1);
 274         if (NULL == func_data)
 275                 return NET_NFC_ALLOC_FAIL;
 276
 277         func_data->callback = (gpointer)callback;
 278         func_data->user_data = user_data;
 279
 280         net_nfc_gdbus_ndef_call_make_read_only(ndef_proxy,
 281                         GPOINTER_TO_UINT(handle),
 282                         net_nfc_client_gdbus_get_privilege(),
 283                         NULL,
 284                         ndef_call_make_read_only,
 285                         func_data);
 286
 287         return NET_NFC_OK;
 288 }
 289
 290 API net_nfc_error_e net_nfc_client_ndef_make_read_only_sync(
 291                 net_nfc_target_handle_s *handle)
 292 {
 293         gboolean ret;
 294         GError *error = NULL;
 295         net_nfc_error_e out_result = NET_NFC_OK;
 296
 297         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 298         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 299
 300         /* prevent executing daemon when nfc is off */
 301         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 302         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 303         RETV_IF(ndef_is_supported_tag() == FALSE, NET_NFC_NOT_SUPPORTED);
 304
 305         ret = net_nfc_gdbus_ndef_call_make_read_only_sync(ndef_proxy,
 306                         GPOINTER_TO_UINT(handle),
 307                         net_nfc_client_gdbus_get_privilege(),
 308                         (gint *)&out_result,
 309                         NULL,
 310                         &error);
 311
 312         if (FALSE == ret)
 313         {
 314                 NFC_ERR("can not make read only: %s", error->message);
 315                 g_error_free(error);
 316                 out_result = NET_NFC_IPC_FAIL;
 317         }
 318
 319         return out_result;
 320 }
 321
 322 API net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_s *handle,
 323                 data_s *key, net_nfc_client_ndef_format_completed callback, void *user_data)
 324 {
 325         GVariant *arg_data;
 326         NetNfcCallback *func_data;
 327
 328         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 329         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 330
 331         /* prevent executing daemon when nfc is off */
 332         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 333         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 334
 335         func_data = g_try_new0(NetNfcCallback, 1);
 336         if (NULL == func_data)
 337                 return NET_NFC_ALLOC_FAIL;
 338
 339         func_data->callback = (gpointer)callback;
 340         func_data->user_data = user_data;
 341
 342         arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
 343
 344         net_nfc_gdbus_ndef_call_format(ndef_proxy,
 345                         GPOINTER_TO_UINT(handle),
 346                         arg_data,
 347                         net_nfc_client_gdbus_get_privilege(),
 348                         NULL,
 349                         ndef_call_format,
 350                         func_data);
 351
 352         return NET_NFC_OK;
 353 }
 354
 355 API net_nfc_error_e net_nfc_client_ndef_format_sync(
 356                 net_nfc_target_handle_s *handle, data_s *key)
 357 {
 358         gboolean ret;
 359         GVariant *arg_data;
 360         GError *error = NULL;
 361         net_nfc_error_e out_result = NET_NFC_OK;
 362
 363         RETV_IF(NULL == handle, NET_NFC_NULL_PARAMETER);
 364         RETV_IF(NULL == ndef_proxy, NET_NFC_NOT_INITIALIZED);
 365
 366         /* prevent executing daemon when nfc is off */
 367         RETV_IF(net_nfc_client_manager_is_activated() == false, NET_NFC_INVALID_STATE);
 368         RETV_IF(net_nfc_client_tag_is_connected() == FALSE, NET_NFC_NOT_CONNECTED);
 369
 370         arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
 371
 372         ret = net_nfc_gdbus_ndef_call_format_sync(ndef_proxy,
 373                         GPOINTER_TO_UINT(handle),
 374                         arg_data,
 375                         net_nfc_client_gdbus_get_privilege(),
 376                         (gint *)&out_result,
 377                         NULL,
 378                         &error);
 379
 380         if (FALSE == ret)
 381         {
 382                 NFC_ERR("can not call format: %s", error->message);
 383                 g_error_free(error);
 384                 out_result = NET_NFC_IPC_FAIL;
 385         }
 386
 387         return out_result;
 388 }
 389
 390 net_nfc_error_e net_nfc_client_ndef_init(void)
 391 {
 392         GError *error = NULL;
 393
 394         if (ndef_proxy)
 395         {
 396                 NFC_WARN("Already initialized");
 397                 return NET_NFC_OK;
 398         }
 399
 400         ndef_proxy = net_nfc_gdbus_ndef_proxy_new_for_bus_sync(
 401                         G_BUS_TYPE_SYSTEM,
 402                         G_DBUS_PROXY_FLAGS_NONE,
 403                         "org.tizen.NetNfcService",
 404                         "/org/tizen/NetNfcService/Ndef",
 405                         NULL,
 406                         &error);
 407
 408         if (NULL == ndef_proxy)
 409         {
 410                 NFC_ERR("Can not create proxy : %s", error->message);
 411                 g_error_free(error);
 412                 return NET_NFC_UNKNOWN_ERROR;
 413         }
 414
 415         return NET_NFC_OK;
 416 }
 417
 418 void net_nfc_client_ndef_deinit(void)
 419 {
 420         if (ndef_proxy)
 421         {
 422                 g_object_unref(ndef_proxy);
 423                 ndef_proxy = NULL;
 424         }
 425 }