2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
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
8 * http://floralicense.org/license/
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.
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_util_internal.h"
27 #include "net_nfc_client_manager.h"
28 #include "net_nfc_client_ndef.h"
29 #include "net_nfc_client_tag_internal.h"
31 #ifndef NET_NFC_EXPORT_API
32 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
37 static NetNfcGDbusNdef *ndef_proxy = NULL;
39 static gboolean ndef_is_supported_tag(void);
41 static void ndef_call_read(GObject *source_object,
45 static void ndef_call_write(GObject *source_object,
49 static void ndef_call_make_read_only(GObject *source_object,
53 static void ndef_call_format(GObject *source_object,
57 static gboolean ndef_is_supported_tag(void)
59 net_nfc_target_info_s *target_info = NULL;
61 target_info = net_nfc_client_tag_get_client_target_info();
62 if (target_info == NULL) {
63 DEBUG_ERR_MSG("target_info does not exist");
68 switch (target_info->devType) {
69 case NET_NFC_ISO14443_A_PICC:
70 case NET_NFC_MIFARE_MINI_PICC:
71 case NET_NFC_MIFARE_1K_PICC:
72 case NET_NFC_MIFARE_4K_PICC:
73 case NET_NFC_MIFARE_ULTRA_PICC:
74 case NET_NFC_JEWEL_PICC:
79 "not supported tag for read only tag");
84 static void ndef_call_read(GObject *source_object,
88 NetNfcCallback *func_data = (NetNfcCallback *)user_data;
89 net_nfc_error_e out_result;
90 GVariant *out_data = NULL;
93 g_assert(user_data != NULL);
95 if (net_nfc_gdbus_ndef_call_read_finish(
96 NET_NFC_GDBUS_NDEF(source_object),
101 DEBUG_ERR_MSG("Can not finish read: %s", error->message);
102 out_result = NET_NFC_IPC_FAIL;
107 if (func_data->callback != NULL) {
108 net_nfc_client_ndef_read_completed callback =
109 (net_nfc_client_ndef_read_completed)func_data->callback;
110 ndef_message_h message;
112 message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
114 callback(out_result, message, func_data->user_data);
116 net_nfc_util_free_ndef_message(message);
122 static void ndef_call_write(GObject *source_object,
126 NetNfcCallback *func_data = (NetNfcCallback *)user_data;
127 net_nfc_error_e out_result;
128 GError *error = NULL;
130 g_assert(user_data != NULL);
132 if (net_nfc_gdbus_ndef_call_write_finish(
133 NET_NFC_GDBUS_NDEF(source_object),
137 DEBUG_ERR_MSG("Can not finish write: %s", error->message);
138 out_result = NET_NFC_IPC_FAIL;
143 if (func_data->callback != NULL) {
144 net_nfc_client_ndef_write_completed callback =
145 (net_nfc_client_ndef_write_completed)func_data->callback;
147 callback(out_result, func_data->user_data);
153 static void ndef_call_make_read_only(GObject *source_object,
157 NetNfcCallback *func_data = (NetNfcCallback *)user_data;
158 net_nfc_error_e out_result;
159 GError *error = NULL;
161 g_assert(user_data != NULL);
163 if (net_nfc_gdbus_ndef_call_make_read_only_finish(
164 NET_NFC_GDBUS_NDEF(source_object),
168 DEBUG_ERR_MSG("Can not finish make read only: %s",
170 out_result = NET_NFC_IPC_FAIL;
175 if (func_data->callback != NULL) {
176 net_nfc_client_ndef_make_read_only_completed callback =
177 (net_nfc_client_ndef_make_read_only_completed)func_data->callback;
179 callback(out_result, func_data->user_data);
185 static void ndef_call_format(GObject *source_object,
189 NetNfcCallback *func_data = (NetNfcCallback *)user_data;
190 net_nfc_error_e out_result;
191 GError *error = NULL;
193 g_assert(user_data != NULL);
195 if (net_nfc_gdbus_ndef_call_format_finish(
196 NET_NFC_GDBUS_NDEF(source_object),
200 DEBUG_ERR_MSG("Can not finish format: %s", error->message);
201 out_result = NET_NFC_IPC_FAIL;
206 if (func_data->callback != NULL) {
207 net_nfc_client_ndef_format_completed callback =
208 (net_nfc_client_ndef_format_completed)func_data->callback;
210 callback(out_result, func_data->user_data);
217 net_nfc_error_e net_nfc_client_ndef_read(net_nfc_target_handle_h handle,
218 net_nfc_client_ndef_read_completed callback,
221 NetNfcCallback *func_data;
224 return NET_NFC_NULL_PARAMETER;
226 if (ndef_proxy == NULL) {
227 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
228 DEBUG_ERR_MSG("tag_proxy fail");
229 return NET_NFC_NOT_INITIALIZED;
233 /* prevent executing daemon when nfc is off */
234 if (net_nfc_client_manager_is_activated() == false)
235 return NET_NFC_NOT_ACTIVATED;
237 if (net_nfc_client_tag_is_connected() == FALSE)
238 return NET_NFC_NOT_CONNECTED;
240 DEBUG_CLIENT_MSG("send request :: read ndef = [%p]", handle);
242 func_data = g_try_new0(NetNfcCallback, 1);
243 if (func_data == NULL)
244 return NET_NFC_ALLOC_FAIL;
246 func_data->callback = (gpointer)callback;
247 func_data->user_data = user_data;
249 net_nfc_gdbus_ndef_call_read(ndef_proxy,
250 GPOINTER_TO_UINT(handle),
259 net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle,
260 ndef_message_h *message)
262 net_nfc_error_e out_result = NET_NFC_OK;
263 GVariant *out_data = NULL;
264 GError *error = NULL;
267 return NET_NFC_NULL_PARAMETER;
269 if (ndef_proxy == NULL) {
270 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
271 DEBUG_ERR_MSG("tag_proxy fail");
272 return NET_NFC_NOT_INITIALIZED;
276 /* prevent executing daemon when nfc is off */
277 if (net_nfc_client_manager_is_activated() == false)
278 return NET_NFC_NOT_ACTIVATED;
280 if (net_nfc_client_tag_is_connected() == FALSE)
281 return NET_NFC_NOT_CONNECTED;
283 DEBUG_CLIENT_MSG("send request :: read ndef = [%p]", handle);
285 if (net_nfc_gdbus_ndef_call_read_sync(ndef_proxy,
286 GPOINTER_TO_UINT(handle),
291 *message = net_nfc_util_gdbus_variant_to_ndef_message(out_data);
293 DEBUG_ERR_MSG("can not call read: %s",
295 out_result = NET_NFC_IPC_FAIL;
304 net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle,
305 ndef_message_h message,
306 net_nfc_client_ndef_write_completed callback,
309 NetNfcCallback *func_data;
312 if (handle == NULL || message == NULL)
313 return NET_NFC_NULL_PARAMETER;
315 if (ndef_proxy == NULL) {
316 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
317 DEBUG_ERR_MSG("tag_proxy fail");
318 return NET_NFC_NOT_INITIALIZED;
322 /* prevent executing daemon when nfc is off */
323 if (net_nfc_client_manager_is_activated() == false)
324 return NET_NFC_NOT_ACTIVATED;
326 if (net_nfc_client_tag_is_connected() == FALSE)
327 return NET_NFC_NOT_CONNECTED;
329 func_data = g_try_new0(NetNfcCallback, 1);
330 if (func_data == NULL)
331 return NET_NFC_ALLOC_FAIL;
333 func_data->callback = (gpointer)callback;
334 func_data->user_data = user_data;
336 arg_data = net_nfc_util_gdbus_ndef_message_to_variant(message);
338 net_nfc_gdbus_ndef_call_write(ndef_proxy,
339 GPOINTER_TO_UINT(handle),
349 net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handle,
350 ndef_message_h message)
352 net_nfc_error_e out_result = NET_NFC_OK;
353 GError *error = NULL;
356 if (handle == NULL || message == NULL)
357 return NET_NFC_NULL_PARAMETER;
359 if (ndef_proxy == NULL) {
360 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
361 DEBUG_ERR_MSG("tag_proxy fail");
362 return NET_NFC_NOT_INITIALIZED;
366 /* prevent executing daemon when nfc is off */
367 if (net_nfc_client_manager_is_activated() == false)
368 return NET_NFC_NOT_ACTIVATED;
370 if (net_nfc_client_tag_is_connected() == FALSE)
371 return NET_NFC_NOT_CONNECTED;
373 arg_data = net_nfc_util_gdbus_ndef_message_to_variant(message);
375 if (net_nfc_gdbus_ndef_call_write_sync(ndef_proxy ,
376 GPOINTER_TO_UINT(handle),
381 DEBUG_ERR_MSG("can not call write: %s",
383 out_result = NET_NFC_IPC_FAIL;
392 net_nfc_error_e net_nfc_client_ndef_make_read_only(
393 net_nfc_target_handle_h handle,
394 net_nfc_client_ndef_make_read_only_completed callback,
397 NetNfcCallback *func_data;
400 return NET_NFC_NULL_PARAMETER;
402 if (ndef_proxy == NULL) {
403 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
404 DEBUG_ERR_MSG("tag_proxy fail");
405 return NET_NFC_NOT_INITIALIZED;
409 /* prevent executing daemon when nfc is off */
410 if (net_nfc_client_manager_is_activated() == false)
411 return NET_NFC_NOT_ACTIVATED;
413 if (net_nfc_client_tag_is_connected() == FALSE)
414 return NET_NFC_NOT_CONNECTED;
416 if (ndef_is_supported_tag() == FALSE)
417 return NET_NFC_NOT_SUPPORTED;
419 func_data = g_try_new0(NetNfcCallback, 1);
420 if (func_data == NULL)
421 return NET_NFC_ALLOC_FAIL;
423 func_data->callback = (gpointer)callback;
424 func_data->user_data = user_data;
426 net_nfc_gdbus_ndef_call_make_read_only(ndef_proxy,
427 GPOINTER_TO_UINT(handle),
429 ndef_call_make_read_only,
436 net_nfc_error_e net_nfc_client_ndef_make_read_only_sync(
437 net_nfc_target_handle_h handle)
439 net_nfc_error_e out_result = NET_NFC_OK;
440 GError *error = NULL;
443 return NET_NFC_NULL_PARAMETER;
445 if (ndef_proxy == NULL) {
446 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
447 DEBUG_ERR_MSG("tag_proxy fail");
448 return NET_NFC_NOT_INITIALIZED;
452 /* prevent executing daemon when nfc is off */
453 if (net_nfc_client_manager_is_activated() == false)
454 return NET_NFC_NOT_ACTIVATED;
456 if (net_nfc_client_tag_is_connected() == FALSE)
457 return NET_NFC_NOT_CONNECTED;
459 if (ndef_is_supported_tag() == FALSE)
460 return NET_NFC_NOT_SUPPORTED;
462 if (net_nfc_gdbus_ndef_call_make_read_only_sync(ndef_proxy,
463 GPOINTER_TO_UINT(handle),
467 DEBUG_ERR_MSG("can not make read only: %s",
469 out_result = NET_NFC_IPC_FAIL;
478 net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
480 net_nfc_client_ndef_format_completed callback,
483 NetNfcCallback *func_data;
487 return NET_NFC_NULL_PARAMETER;
489 if (ndef_proxy == NULL) {
490 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
491 DEBUG_ERR_MSG("tag_proxy fail");
492 return NET_NFC_NOT_INITIALIZED;
496 /* prevent executing daemon when nfc is off */
497 if (net_nfc_client_manager_is_activated() == false)
498 return NET_NFC_NOT_ACTIVATED;
500 if (net_nfc_client_tag_is_connected() == FALSE)
501 return NET_NFC_NOT_CONNECTED;
503 func_data = g_try_new0(NetNfcCallback, 1);
504 if (func_data == NULL)
505 return NET_NFC_ALLOC_FAIL;
507 func_data->callback = (gpointer)callback;
508 func_data->user_data = user_data;
510 arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
512 net_nfc_gdbus_ndef_call_format(ndef_proxy ,
513 GPOINTER_TO_UINT(handle),
523 net_nfc_error_e net_nfc_client_ndef_format_sync(
524 net_nfc_target_handle_h handle,
527 net_nfc_error_e out_result = NET_NFC_OK;
529 GError *error = NULL;
532 return NET_NFC_NULL_PARAMETER;
534 if (ndef_proxy == NULL) {
535 if (net_nfc_client_ndef_init() != NET_NFC_OK) {
536 DEBUG_ERR_MSG("tag_proxy fail");
537 return NET_NFC_NOT_INITIALIZED;
541 /* prevent executing daemon when nfc is off */
542 if (net_nfc_client_manager_is_activated() == false)
543 return NET_NFC_NOT_ACTIVATED;
545 if (net_nfc_client_tag_is_connected() == FALSE)
546 return NET_NFC_NOT_CONNECTED;
548 arg_data = net_nfc_util_gdbus_data_to_variant((data_s *)key);
550 if (net_nfc_gdbus_ndef_call_format_sync(ndef_proxy ,
551 GPOINTER_TO_UINT(handle),
556 DEBUG_ERR_MSG("can not call format: %s",
558 out_result = NET_NFC_IPC_FAIL;
566 net_nfc_error_e net_nfc_client_ndef_init(void)
568 GError *error = NULL;
571 DEBUG_CLIENT_MSG("Already initialized");
576 ndef_proxy = net_nfc_gdbus_ndef_proxy_new_for_bus_sync(
578 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
579 "org.tizen.NetNfcService",
580 "/org/tizen/NetNfcService/Ndef",
583 if (ndef_proxy == NULL) {
584 DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
587 return NET_NFC_UNKNOWN_ERROR;
593 void net_nfc_client_ndef_deinit(void)
596 g_object_unref(ndef_proxy);