Add unittest for coverage
authorJihoon Jung <jh8801.jung@samsung.com>
Tue, 30 Jun 2020 05:23:43 +0000 (14:23 +0900)
committerJihoon Jung <jh8801.jung@samsung.com>
Tue, 30 Jun 2020 05:23:43 +0000 (14:23 +0900)
Signed-off-by: Jihoon Jung <jh8801.jung@samsung.com>
23 files changed:
CMakeLists.txt
packaging/capi-network-nfc.spec
unittest/CMakeLists.txt [new file with mode: 0644]
unittest/include/assert_local.h [new file with mode: 0755]
unittest/include/tct_common.h [new file with mode: 0755]
unittest/include/testcase.h [new file with mode: 0755]
unittest/mock/nfc-mock-hce.c [new file with mode: 0755]
unittest/mock/nfc-mock-manager.c [new file with mode: 0755]
unittest/mock/nfc-mock-p2p.c [new file with mode: 0755]
unittest/mock/nfc-mock-popup.c [new file with mode: 0755]
unittest/mock/nfc-mock-se.c [new file with mode: 0755]
unittest/mock/nfc-mock-snep.c [new file with mode: 0755]
unittest/mock/nfc-mock-tag.c [new file with mode: 0755]
unittest/mock/nfc-mock.c [new file with mode: 0755]
unittest/net_nfc_gdbus.c [new file with mode: 0644]
unittest/net_nfc_gdbus.h [new file with mode: 0755]
unittest/run_coverage.sh [new file with mode: 0755]
unittest/tct-nfc-core.cpp [new file with mode: 0755]
unittest/tct-nfc-core.h [new file with mode: 0755]
unittest/utc-network-nfc-hce.c [new file with mode: 0755]
unittest/utc-network-nfc-ndef-message.c [new file with mode: 0755]
unittest/utc-network-nfc-ndef-record.c [new file with mode: 0755]
unittest/utc-network-nfc.c [new file with mode: 0755]

index 36b7ac2..d1c40aa 100644 (file)
@@ -42,13 +42,17 @@ INCLUDE(FindPkgConfig)
 pkg_check_modules(${fw_name} REQUIRED ${dependents})
 FOREACH(flag ${${fw_name}_CFLAGS})
     SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+    SET(EXTRA_CXXFLAGS "${EXTRA_CXXFLAGS} ${flag}")
 ENDFOREACH(flag)
 IF(BUILD_GCOV)
        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -fprofile-arcs -ftest-coverage")
+       SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fPIC -Wall -Werror -fprofile-arcs -ftest-coverage")
 ELSE(BUILD_GCOV)
        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror")
+       SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} -fPIC -Wall -Werror")
 ENDIF(BUILD_GCOV)
 SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
 
 IF("${ARCH}" STREQUAL "arm")
     ADD_DEFINITIONS("-DTARGET")
@@ -93,6 +97,10 @@ INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIBDIR}/pk
 
 ADD_SUBDIRECTORY(test)
 
+IF(BUILD_GCOV)
+       ADD_SUBDIRECTORY(unittest)
+ENDIF(BUILD_GCOV)
+
 IF(UNIX)
 
 ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
index 75e21fb..191d4bb 100644 (file)
@@ -16,6 +16,11 @@ BuildRequires:  pkgconfig(nfc-common-lib)
 BuildRequires:  pkgconfig(aul)
 BuildRequires:  pkgconfig(libsystemd-daemon)
 
+%if 0%{?gcov:1}
+BuildRequires:  gtest-devel
+BuildRequires:  lcov
+%endif
+
 Requires(post): /sbin/ldconfig
 Requires(postun): /sbin/ldconfig
 
@@ -73,6 +78,13 @@ mkdir -p %{buildroot}%{_datadir}/gcov/obj
 install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj
 %endif
 
+%check
+%if 0%{?gcov:1}
+pushd unittest
+./run_coverage.sh
+popd
+%endif
+
 %post -p /sbin/ldconfig
 
 %postun -p /sbin/ldconfig
diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt
new file mode 100644 (file)
index 0000000..56ad695
--- /dev/null
@@ -0,0 +1,56 @@
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib")
+
+SET(UNITTEST_NAME "tct-nfc-core")
+
+SET(CAPI_LIB "capi-network-nfc")
+SET(TC_SOURCES
+    utc-network-nfc-hce.c
+    utc-network-nfc-ndef-record.c
+    utc-network-nfc-ndef-message.c
+    utc-network-nfc.c
+)
+
+PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED
+    capi-base-common
+    dlog
+    capi-system-info
+    glib-2.0
+    gio-unix-2.0
+)
+
+INCLUDE_DIRECTORIES(
+    ${${CAPI_LIB}_INCLUDE_DIRS}
+    ${CMAKE_SOURCE_DIR}/src/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+ADD_DEFINITIONS( -DMOBILE )
+
+SET(NFC_MOCK "nfc-mock")
+SET(NFC_MOCK_SRCS
+       mock/nfc-mock.c
+       mock/nfc-mock-hce.c
+       mock/nfc-mock-manager.c
+       mock/nfc-mock-p2p.c
+       mock/nfc-mock-popup.c
+       mock/nfc-mock-se.c
+       mock/nfc-mock-snep.c
+       mock/nfc-mock-tag.c
+)
+
+SET(NFC_MOCK_CFLAGS "${CMAKE_C_FLAGS}" )
+ADD_LIBRARY(${NFC_MOCK} SHARED ${NFC_MOCK_SRCS})
+SET_TARGET_PROPERTIES(${NFC_MOCK} PROPERTIES
+       COMPILE_FLAGS ${NFC_MOCK_CFLAGS}
+)
+
+ADD_EXECUTABLE(${UNITTEST_NAME} ${UNITTEST_NAME}.cpp ${TC_SOURCES} )
+TARGET_LINK_LIBRARIES(${UNITTEST_NAME}
+    ${${CAPI_LIB}_LIBRARIES}
+    ${LIB_NAME}
+    gtest
+    pthread
+    capi-network-nfc
+)
+
+# INSTALL(PROGRAMS ${UNITTEST_NAME} DESTINATION ${BIN_INSTALL_DIR})
diff --git a/unittest/include/assert_local.h b/unittest/include/assert_local.h
new file mode 100755 (executable)
index 0000000..7c88a02
--- /dev/null
@@ -0,0 +1,118 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef _ASSERT_H_
+#define _ASSERT_H_
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define assert(exp) \
+    do { \
+        if (!(exp)) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert Fail; Following expression is not true: %s\n", \
+                __FILE__, __LINE__, #exp); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_eq(var, ref) \
+    do { \
+        if (var != ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are not equal\n", \
+                __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_eq_no_return(var, ref) \
+    do { \
+        if (var != ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are not equal\n", \
+                __FILE__, __LINE__, #var, (int)var, #ref, (int)ref); \
+            return ; \
+        } \
+    } while (0)
+
+#define assert_neq_no_return(var, ref) \
+    do { \
+        if (var == ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are equal\n", \
+                __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return ; \
+        } \
+    } while (0)
+
+#define assert_neq(var, ref) \
+    do { \
+        if (var == ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) and (%s == 0x%x) are equal\n", \
+                __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_gt(var, ref) \
+    do { \
+        if (var <= ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than (%s == 0x%x)\n", \
+            __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_geq(var, ref) \
+    do { \
+        if (var < ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not greater than or equal to (%s == 0x%x)\n", \
+                __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_lt(var, ref) \
+    do { \
+        if (var >= ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than (%s == 0x%x)\n", \
+                __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#define assert_leq(var, ref) \
+    do { \
+        if (var > ref) { \
+            fprintf(stderr, \
+                "\n[TCT][%s][Line : %d] Assert fail; Values (%s == 0x%x) is not lower than or equal to (%s == 0x%x)\n", \
+            __FILE__, __LINE__,  #var, (int)var, #ref, (int)ref); \
+            return 1; \
+        } \
+    } while (0)
+
+#ifdef __cplusplus
+}
+#endif
+#endif //  _ASSERT_H_
diff --git a/unittest/include/tct_common.h b/unittest/include/tct_common.h
new file mode 100755 (executable)
index 0000000..5617478
--- /dev/null
@@ -0,0 +1,216 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef _TCT_COMMON_H_
+#define _TCT_COMMON_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "assert_local.h"
+
+#include <malloc.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#define CONFIG_LINE_LEN_MAX                    2048
+#define CONFIG_VALUE_LEN_MAX           1024
+
+#define UTC_LOG "utc.log"
+#define ERR_UTC_LOG "utc_error.log"
+#define TC_RESULT "tc_result.log"
+
+FILE *g_fpLog;
+FILE *g_fpLogDump;
+int g_Serr;
+
+int old_Serr;
+
+#define FPRINTF(...) {\
+       g_fpLog = fopen(ERR_LOG, "a");\
+       fprintf(g_fpLog, __VA_ARGS__);\
+       fclose(g_fpLog);\
+}
+
+#define DUMP_UTC_ERRLOG() {\
+       g_Serr = dup(fileno(stderr));\
+       g_fpLogDump = freopen(ERR_UTC_LOG, "w", stderr);\
+       fflush(stderr);\
+}
+
+#define CLOSE_UTC_ERRLOG() {\
+       if(g_fpLogDump) \
+       {\
+               if (g_Serr != -1)\
+               {\
+                       old_Serr = fileno(stderr);\
+                       if(old_Serr != -1)\
+                       {\
+                               dup2(g_Serr, old_Serr);\
+                       }\
+                       close(g_Serr);\
+               }\
+               fclose(g_fpLogDump);\
+       }\
+}
+
+#define PRINT_TC_RESULT(...) {\
+       g_fpLog = fopen(TC_RESULT, "w");\
+       fprintf(g_fpLog, __VA_ARGS__);\
+       fclose(g_fpLog);\
+}
+
+
+#define FREE_MEMORY_TC(buffer) {\
+       if ( buffer != NULL )\
+{\
+       free(buffer);\
+       buffer = NULL;\
+}\
+}
+
+
+#define IS_FEATURE_SUPPORTED(feature_name, featureFlag, ModuleName)\
+{\
+       if ( !(TCTCheckSystemInfoFeatureSupported(feature_name, ModuleName)) )\
+{\
+       featureFlag = false;\
+}\
+       else\
+{\
+       featureFlag = true;\
+}\
+}
+
+#define PRINT_RESULT(eCompare, eRetVal, API, Error) {\
+       if ( eRetVal == eCompare )\
+{\
+       if ( DEBUG )\
+{\
+       FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\
+}\
+}\
+       else \
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\
+       return 1;\
+}\
+}
+
+#define PRINT_RESULT_NORETURN(eCompare, eRetVal, API, Error) {\
+       if ( eRetVal == eCompare )\
+{\
+       if ( DEBUG )\
+{\
+       FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\
+}\
+}\
+       else \
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\
+}\
+}
+
+#define PRINT_RESULT_CLEANUP(eCompare, eRetVal, API, Error, FreeResource) {\
+       if ( eRetVal == eCompare )\
+{\
+       if ( DEBUG )\
+{\
+       FPRINTF("[Line : %d][%s] %s passed\\n", __LINE__, API_NAMESPACE, API);\
+}\
+}\
+else \
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = %s [%d]\\n", __LINE__, API_NAMESPACE, API, Error, eRetVal);\
+       FreeResource;\
+       return 1;\
+}\
+}
+
+#define CHECK_VALUE_STRING(StringVariable, API) {\
+       if ( StringVariable == NULL )\
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = value returned is NULL\\n", __LINE__, API_NAMESPACE, API);\
+       return 1;\
+}\
+       else if ( DEBUG )\
+{\
+       FPRINTF("[Line : %d][%s] value returned = %s\\n", __LINE__, API_NAMESPACE, StringVariable);\
+}\
+       free(StringVariable);\
+       StringVariable = NULL;\
+}
+
+#define CHECK_VALUE_INT(Variable, API) {\
+       if ( Variable == 0 )\
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = value returned is Zero\\n", __LINE__, API_NAMESPACE, API);\
+       return 1;\
+}\
+       else if ( DEBUG )\
+{\
+       FPRINTF("[Line : %d][%s] value returned = %d\\n", __LINE__, API_NAMESPACE, Variable);\
+}\
+}
+
+#define CHECK_HANDLE(Handle, API) {\
+       if ( Handle == NULL )\
+{\
+       FPRINTF("[Line : %d][%s] %s failed, error returned = Handle returned is NULL\\n", __LINE__, API_NAMESPACE, API);\
+       return 1;\
+}\
+}
+
+#define FREE_MEMORY(buffer) {\
+       if ( buffer != NULL )\
+{\
+       free(buffer);\
+       buffer = NULL;\
+}\
+}
+
+bool TCTCheckSystemInfoFeatureSupported(char* pszKey, char* pszModuleName){
+    return false;
+}
+char* TCTSystemInfoGetError(int nRet){
+    return NULL;
+}
+bool GetValueFromConfigFile(char* pstrKeyString, char* pstrValue, char* pstrModule){
+    return false;
+}
+bool GetValueForTCTSetting(char* pstrKeyString, char* pstrValue, char* pstrModule){
+    return false;
+}
+
+#define dlog_print( type, tag, ...) do{ \
+    fprintf(stdout,  ##__VA_ARGS__ ); \
+    fprintf(stdout,  "\n" ); \
+} while(0)
+
+#define PRINT_UTC_LOG(...) do{ \
+    fprintf(stdout,  ##__VA_ARGS__ ); \
+    fprintf(stdout,  "\n" ); \
+} while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _TCT_COMMON_H_
diff --git a/unittest/include/testcase.h b/unittest/include/testcase.h
new file mode 100755 (executable)
index 0000000..febac28
--- /dev/null
@@ -0,0 +1,40 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef _TESTCASE_H_
+#define _TESTCASE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* pointer to startup/cleanup functions */
+typedef void (*void_fun_ptr)(void);
+
+/* pointer to testcase functions */
+typedef int (*tc_fun_ptr)(void);
+
+/* struct describing specific testcase */
+typedef struct testcase_s {
+    const char* name;
+    tc_fun_ptr function;
+    void_fun_ptr startup;
+    void_fun_ptr cleanup;
+} testcase;
+
+#ifdef __cplusplus
+}
+#endif
+#endif // _TESTCASE_H_
diff --git a/unittest/mock/nfc-mock-hce.c b/unittest/mock/nfc-mock-hce.c
new file mode 100755 (executable)
index 0000000..875e36d
--- /dev/null
@@ -0,0 +1,81 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusHce;
+typedef struct _NetNfcGDbusHce NetNfcGDbusHce;
+typedef struct _NetNfcGDbusHceIface NetNfcGDbusHceIface;
+
+struct _NetNfcGDbusHceIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_response_apdu) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    GVariant *arg_data);
+
+  gboolean (*handle_start_hce_handler) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_stop_hce_handler) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation);
+
+  void (*event_received) (
+    NetNfcGDbusHce *object,
+    guint arg_handle,
+    guint arg_event,
+    GVariant *arg_apdu);
+
+};
+
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_proxy_new_for_bus_sync(
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+       return (void *)1234;
+}
+
+gboolean
+net_nfc_gdbus_hce_call_start_hce_handler_sync(
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+       return true;
+}
diff --git a/unittest/mock/nfc-mock-manager.c b/unittest/mock/nfc-mock-manager.c
new file mode 100755 (executable)
index 0000000..1246525
--- /dev/null
@@ -0,0 +1,106 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusManager;
+typedef struct _NetNfcGDbusManager NetNfcGDbusManager;
+typedef struct _NetNfcGDbusManagerIface NetNfcGDbusManagerIface;
+
+struct _NetNfcGDbusManagerIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_configure_discovery) (
+               NetNfcGDbusManager *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_mode);
+
+       gboolean (*handle_get_server_state) (
+               NetNfcGDbusManager *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_set_active) (
+               NetNfcGDbusManager *object,
+               GDBusMethodInvocation *invocation,
+               gboolean arg_is_active);
+
+       void (*activated) (
+               NetNfcGDbusManager *object,
+               gboolean arg_active);
+};
+
+API NetNfcGDbusManager *net_nfc_gdbus_manager_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
+
+API void net_nfc_gdbus_manager_call_set_active(
+       NetNfcGDbusManager *proxy,
+       gboolean arg_is_active,
+       GCancellable *cancellable,
+       GAsyncReadyCallback callback,
+       gpointer user_data)
+{
+       return;
+}
+
+API gboolean net_nfc_gdbus_manager_call_set_active_sync(
+       NetNfcGDbusManager *proxy,
+       gboolean arg_is_active,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_manager_call_get_server_state_sync (
+       NetNfcGDbusManager *proxy,
+       gint *out_result,
+       guint *out_state,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_manager_call_configure_discovery_sync (
+       NetNfcGDbusManager *proxy,
+       gint arg_mode,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
diff --git a/unittest/mock/nfc-mock-p2p.c b/unittest/mock/nfc-mock-p2p.c
new file mode 100755 (executable)
index 0000000..e4ee40a
--- /dev/null
@@ -0,0 +1,66 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusP2p;
+typedef struct _NetNfcGDbusP2p NetNfcGDbusP2p;
+typedef struct _NetNfcGDbusP2pIface NetNfcGDbusP2pIface;
+
+struct _NetNfcGDbusP2pIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_send) (
+               NetNfcGDbusP2p *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_type,
+               GVariant *arg_data,
+               guint arg_handle);
+
+       void (*detached) (
+               NetNfcGDbusP2p *object);
+
+       void (*discovered) (
+               NetNfcGDbusP2p *object,
+               guint arg_handle);
+
+       void (*received) (
+               NetNfcGDbusP2p *object,
+               GVariant *arg_data);
+};
+
+API NetNfcGDbusP2p *net_nfc_gdbus_p2p_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
diff --git a/unittest/mock/nfc-mock-popup.c b/unittest/mock/nfc-mock-popup.c
new file mode 100755 (executable)
index 0000000..35e6c6a
--- /dev/null
@@ -0,0 +1,79 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusPopup;
+typedef struct _NetNfcGDbusPopup NetNfcGDbusPopup;
+typedef struct _NetNfcGDbusPopupIface NetNfcGDbusPopupIface;
+
+struct _NetNfcGDbusPopupIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_get) (
+               NetNfcGDbusPopup *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_set) (
+               NetNfcGDbusPopup *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_state,
+               gint arg_focus_state);
+};
+
+API NetNfcGDbusPopup *net_nfc_gdbus_popup_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
+
+API gboolean net_nfc_gdbus_popup_call_set_sync(
+       NetNfcGDbusPopup *proxy,
+       gint arg_state,
+       gint arg_focus_state,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_popup_call_get_sync(
+       NetNfcGDbusPopup *proxy,
+       gint *out_result,
+       gint *out_state,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
diff --git a/unittest/mock/nfc-mock-se.c b/unittest/mock/nfc-mock-se.c
new file mode 100755 (executable)
index 0000000..8e9378d
--- /dev/null
@@ -0,0 +1,342 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusSecureElement;
+typedef struct _NetNfcGDbusSecureElement NetNfcGDbusSecureElement;
+typedef struct _NetNfcGDbusSecureElementIface NetNfcGDbusSecureElementIface;
+
+struct _NetNfcGDbusSecureElementIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_add_route_aid) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               const gchar *arg_package,
+               const gchar *arg_aid,
+               guint arg_se_type,
+               guint arg_category,
+               gboolean arg_unlock,
+               guint arg_power);
+
+       gboolean (*handle_check_transaction_permission) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               GVariant *arg_aid);
+
+       gboolean (*handle_close_secure_element) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle);
+
+       gboolean (*handle_get) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_get_atr) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle);
+
+       gboolean (*handle_get_card_emulation) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_get_conflict_handlers) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               const gchar *arg_package,
+               guint arg_category,
+               const gchar *arg_aid);
+
+       gboolean (*handle_get_handler_storage_info) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_category);
+
+       gboolean (*handle_get_registered_aids) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               guint arg_category);
+
+       gboolean (*handle_get_registered_handlers) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_category);
+
+       gboolean (*handle_is_activated_aid_handler) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               const gchar *arg_aid);
+
+       gboolean (*handle_is_activated_category_handler) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               guint arg_category);
+
+       gboolean (*handle_open_secure_element) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_type);
+
+       gboolean (*handle_register_aid) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               guint arg_category,
+               const gchar *arg_aid);
+
+       gboolean (*handle_remove_package_aids) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               const gchar *arg_package);
+
+       gboolean (*handle_remove_route_aid) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               const gchar *arg_package,
+               const gchar *arg_aid);
+
+       gboolean (*handle_send_apdu) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle,
+               GVariant *arg_data);
+
+       gboolean (*handle_set) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_type);
+
+       gboolean (*handle_set_card_emulation) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_mode);
+
+       gboolean (*handle_set_default_route) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_switch_on,
+               guint arg_switch_off,
+               guint arg_battery_off);
+
+       gboolean (*handle_set_preferred_handler) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               gboolean arg_state);
+
+       gboolean (*handle_set_transaction_fg_dispatch) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               gint arg_mode);
+
+       gboolean (*handle_unregister_aid) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               guint arg_category,
+               const gchar *arg_aid);
+
+       gboolean (*handle_unregister_aids) (
+               NetNfcGDbusSecureElement *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_type,
+               guint arg_category);
+
+       void (*card_emulation_mode_changed) (
+               NetNfcGDbusSecureElement *object,
+               gint arg_mode);
+
+       void (*ese_detected) (
+               NetNfcGDbusSecureElement *object,
+               guint arg_handle,
+               gint arg_se_type,
+               GVariant *arg_data);
+
+       void (*rf_detected) (
+               NetNfcGDbusSecureElement *object);
+
+       void (*se_type_changed) (
+               NetNfcGDbusSecureElement *object,
+               gint arg_se_type);
+
+       void (*transaction_event) (
+               NetNfcGDbusSecureElement *object,
+               gint arg_se_type,
+               GVariant *arg_aid,
+               GVariant *arg_param,
+               gint arg_fg_dispatch,
+               gint arg_focus_pgid);
+};
+
+API gboolean net_nfc_gdbus_secure_element_call_get_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gint *out_result,
+       gint *out_type,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_set_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gint arg_type,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_set_default_route_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_switch_on,
+       guint arg_switch_off,
+       guint arg_battery_off,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_register_aid_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_type,
+       guint arg_category,
+       const gchar *arg_aid,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_is_activated_aid_handler_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_type,
+       const gchar *arg_aid,
+       gint *out_result,
+       gboolean *out_activated,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_is_activated_category_handler_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_type,
+       guint arg_category,
+       gint *out_result,
+       gboolean *out_activated,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_unregister_aid_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_type,
+       guint arg_category,
+       const gchar *arg_aid,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_get_registered_aids_sync(
+       NetNfcGDbusSecureElement *proxy,
+       guint arg_type,
+       guint arg_category,
+       gint *out_result,
+       GVariant **out_aids,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_set_card_emulation_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gint arg_mode,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_get_card_emulation_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gint *out_result,
+       gint *out_type,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_set_preferred_handler_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gboolean arg_state,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_sync(
+       NetNfcGDbusSecureElement *proxy,
+       gint arg_mode,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
diff --git a/unittest/mock/nfc-mock-snep.c b/unittest/mock/nfc-mock-snep.c
new file mode 100755 (executable)
index 0000000..bf03452
--- /dev/null
@@ -0,0 +1,121 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusSnep;
+typedef struct _NetNfcGDbusSnep NetNfcGDbusSnep;
+typedef struct _NetNfcGDbusSnepIface NetNfcGDbusSnepIface;
+
+struct _NetNfcGDbusSnepIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_client_request) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_snep_handle,
+               guint arg_type,
+               GVariant *arg_ndef_msg);
+
+       gboolean (*handle_client_start) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle,
+               guint arg_sap,
+               const gchar *arg_san,
+               guint arg_user_data);
+
+       gboolean (*handle_server_register) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_sap,
+               const gchar *arg_san,
+               guint arg_user_data);
+
+       gboolean (*handle_server_start) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle,
+               guint arg_sap,
+               const gchar *arg_san,
+               guint arg_user_data);
+
+       gboolean (*handle_server_unregister) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_sap,
+               const gchar *arg_san);
+
+       gboolean (*handle_stop_snep) (
+               NetNfcGDbusSnep *object,
+               GDBusMethodInvocation *invocation,
+               guint arg_handle,
+               guint arg_snep_handle);
+
+       void (*snep_event) (
+               NetNfcGDbusSnep *object,
+               guint arg_handle,
+               guint arg_event,
+               gint arg_result,
+               GVariant *arg_ndef_msg,
+               guint arg_user_data);
+};
+
+API NetNfcGDbusSnep *net_nfc_gdbus_snep_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
+
+API gboolean net_nfc_gdbus_snep_call_server_register_sync(
+       NetNfcGDbusSnep *proxy,
+       guint arg_sap,
+       const gchar *arg_san,
+       guint arg_user_data,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
+
+API gboolean net_nfc_gdbus_snep_call_server_unregister_sync(
+       NetNfcGDbusSnep *proxy,
+       guint arg_sap,
+       const gchar *arg_san,
+       gint *out_result,
+       GCancellable *cancellable,
+       GError **error)
+{
+       return true;
+}
diff --git a/unittest/mock/nfc-mock-tag.c b/unittest/mock/nfc-mock-tag.c
new file mode 100755 (executable)
index 0000000..c07ead7
--- /dev/null
@@ -0,0 +1,81 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+struct _NetNfcGDbusTag;
+typedef struct _NetNfcGDbusTag NetNfcGDbusTag;
+typedef struct _NetNfcGDbusTagIface NetNfcGDbusTagIface;
+
+struct _NetNfcGDbusTagIface
+{
+       GTypeInterface parent_iface;
+
+       gboolean (*handle_get_barcode) (
+               NetNfcGDbusTag *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_get_current_tag_info) (
+               NetNfcGDbusTag *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_get_current_target_handle) (
+               NetNfcGDbusTag *object,
+               GDBusMethodInvocation *invocation);
+
+       gboolean (*handle_is_tag_connected) (
+               NetNfcGDbusTag *object,
+               GDBusMethodInvocation *invocation);
+
+       void (*tag_detached) (
+               NetNfcGDbusTag *object,
+               guint arg_handle,
+               gint arg_dev_type);
+
+       void (*tag_discovered) (
+               NetNfcGDbusTag *object,
+               guint arg_handle,
+               gint arg_dev_type,
+               gboolean arg_is_ndef_supported,
+               guchar arg_ndef_card_state,
+               guint arg_max_data_size,
+               guint arg_actual_data_size,
+               guint arg_number_of_keys,
+               GVariant *arg_target_info_values,
+               GVariant *arg_raw_data);
+};
+
+API NetNfcGDbusTag *net_nfc_gdbus_tag_proxy_new_for_bus_sync(
+       GBusType             bus_type,
+       GDBusProxyFlags      flags,
+       const gchar         *name,
+       const gchar         *object_path,
+       GCancellable        *cancellable,
+       GError             **error)
+{
+       return (void *)1234;
+}
diff --git a/unittest/mock/nfc-mock.c b/unittest/mock/nfc-mock.c
new file mode 100755 (executable)
index 0000000..6b9a16c
--- /dev/null
@@ -0,0 +1,104 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#ifndef API
+#define API __attribute__ ((visibility("default")))
+#endif
+
+typedef enum {
+       LOG_ID_INVALID = -1,
+       LOG_ID_MAIN,
+       LOG_ID_RADIO,
+       LOG_ID_SYSTEM,
+       LOG_ID_APPS,
+       LOG_ID_KMSG,
+       LOG_ID_SYSLOG,
+       LOG_ID_MAX
+} log_id_t;
+
+API int __dlog_print(log_id_t log_id, int prio, const char *tag, const char *fmt, ...)
+{
+       va_list ap;
+       va_start(ap, fmt);
+       vprintf(fmt, ap);
+       va_end(ap);
+       printf("\n");
+
+       return 0;
+}
+
+API int system_info_get_platform_bool(const char *key, bool *value)
+{
+       *value = true;
+       return 0;
+}
+
+API gulong g_signal_connect_data(gpointer instance,
+       const gchar *detailed_signal,
+       GCallback c_handler,
+       gpointer data,
+       GClosureNotify destroy_data,
+       GConnectFlags connect_flags)
+{
+       return 0;
+}
+
+API int vconf_get_bool(const char *in_key, int *boolval)
+{
+       *boolval = 1;
+
+       return 0;
+}
+
+API GVariant *g_variant_new (const gchar *format_string, ...)
+{
+       return (void *)1234;
+}
+
+API gsize g_variant_iter_init (GVariantIter *iter, GVariant *value)
+{
+       return 0;
+}
+
+API gboolean g_variant_iter_loop (GVariantIter *iter, const gchar  *format_string, ...)
+{
+       return false;
+}
+
+API void g_object_unref (gpointer _object)
+{
+       return;
+}
+
+API void g_dbus_proxy_set_default_timeout (GDBusProxy *proxy, gint timeout_msec)
+{
+       return;
+}
+
+API GTypeInstance* g_type_check_instance_cast (GTypeInstance *type_instance,
+       GType iface_type)
+{
+       return (void *)1234;
+}
diff --git a/unittest/net_nfc_gdbus.c b/unittest/net_nfc_gdbus.c
new file mode 100644 (file)
index 0000000..7daa026
--- /dev/null
@@ -0,0 +1,26429 @@
+/*
+ * Generated by gdbus-codegen 2.56.4. DO NOT EDIT.
+ *
+ * The license of this code is the same as for the D-Bus interface description
+ * it was derived from.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "net_nfc_gdbus.h"
+
+#include <string.h>
+#ifdef G_OS_UNIX
+#  include <gio/gunixfdlist.h>
+#endif
+
+typedef struct
+{
+  GDBusArgInfo parent_struct;
+  gboolean use_gvariant;
+} _ExtendedGDBusArgInfo;
+
+typedef struct
+{
+  GDBusMethodInfo parent_struct;
+  const gchar *signal_name;
+  gboolean pass_fdlist;
+} _ExtendedGDBusMethodInfo;
+
+typedef struct
+{
+  GDBusSignalInfo parent_struct;
+  const gchar *signal_name;
+} _ExtendedGDBusSignalInfo;
+
+typedef struct
+{
+  GDBusPropertyInfo parent_struct;
+  const gchar *hyphen_name;
+  gboolean use_gvariant;
+} _ExtendedGDBusPropertyInfo;
+
+typedef struct
+{
+  GDBusInterfaceInfo parent_struct;
+  const gchar *hyphen_name;
+} _ExtendedGDBusInterfaceInfo;
+
+typedef struct
+{
+  const _ExtendedGDBusPropertyInfo *info;
+  guint prop_id;
+  GValue orig_value; /* the value before the change */
+} ChangedProperty;
+
+static void
+_changed_property_free (ChangedProperty *data)
+{
+  g_value_unset (&data->orig_value);
+  g_free (data);
+}
+
+static gboolean
+_g_strv_equal0 (gchar **a, gchar **b)
+{
+  gboolean ret = FALSE;
+  guint n;
+  if (a == NULL && b == NULL)
+    {
+      ret = TRUE;
+      goto out;
+    }
+  if (a == NULL || b == NULL)
+    goto out;
+  if (g_strv_length (a) != g_strv_length (b))
+    goto out;
+  for (n = 0; a[n] != NULL; n++)
+    if (g_strcmp0 (a[n], b[n]) != 0)
+      goto out;
+  ret = TRUE;
+out:
+  return ret;
+}
+
+static gboolean
+_g_variant_equal0 (GVariant *a, GVariant *b)
+{
+  gboolean ret = FALSE;
+  if (a == NULL && b == NULL)
+    {
+      ret = TRUE;
+      goto out;
+    }
+  if (a == NULL || b == NULL)
+    goto out;
+  ret = g_variant_equal (a, b);
+out:
+  return ret;
+}
+
+G_GNUC_UNUSED static gboolean
+_g_value_equal (const GValue *a, const GValue *b)
+{
+  gboolean ret = FALSE;
+  g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
+  switch (G_VALUE_TYPE (a))
+    {
+      case G_TYPE_BOOLEAN:
+        ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
+        break;
+      case G_TYPE_UCHAR:
+        ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
+        break;
+      case G_TYPE_INT:
+        ret = (g_value_get_int (a) == g_value_get_int (b));
+        break;
+      case G_TYPE_UINT:
+        ret = (g_value_get_uint (a) == g_value_get_uint (b));
+        break;
+      case G_TYPE_INT64:
+        ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
+        break;
+      case G_TYPE_UINT64:
+        ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
+        break;
+      case G_TYPE_DOUBLE:
+        {
+          /* Avoid -Wfloat-equal warnings by doing a direct bit compare */
+          gdouble da = g_value_get_double (a);
+          gdouble db = g_value_get_double (b);
+          ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
+        }
+        break;
+      case G_TYPE_STRING:
+        ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
+        break;
+      case G_TYPE_VARIANT:
+        ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
+        break;
+      default:
+        if (G_VALUE_TYPE (a) == G_TYPE_STRV)
+          ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
+        else
+          g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
+        break;
+    }
+  return ret;
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Manager
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusManager
+ * @title: NetNfcGDbusManager
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Manager D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Manager ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_set_active_IN_ARG_is_active =
+{
+  {
+    -1,
+    (gchar *) "is_active",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_method_info_set_active_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_set_active_IN_ARG_is_active,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_set_active_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_method_info_set_active_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_set_active_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_manager_method_info_set_active =
+{
+  {
+    -1,
+    (gchar *) "SetActive",
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_method_info_set_active_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_method_info_set_active_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-active",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_state =
+{
+  {
+    -1,
+    (gchar *) "state",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_result,
+  &_net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_state,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_manager_method_info_get_server_state =
+{
+  {
+    -1,
+    (gchar *) "GetServerState",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_method_info_get_server_state_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-server-state",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_configure_discovery_IN_ARG_mode =
+{
+  {
+    -1,
+    (gchar *) "mode",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_method_info_configure_discovery_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_configure_discovery_IN_ARG_mode,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_method_info_configure_discovery_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_method_info_configure_discovery_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_configure_discovery_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_manager_method_info_configure_discovery =
+{
+  {
+    -1,
+    (gchar *) "ConfigureDiscovery",
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_method_info_configure_discovery_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_method_info_configure_discovery_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-configure-discovery",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_manager_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_manager_method_info_set_active,
+  &_net_nfc_gdbus_manager_method_info_get_server_state,
+  &_net_nfc_gdbus_manager_method_info_configure_discovery,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_manager_signal_info_activated_ARG_active =
+{
+  {
+    -1,
+    (gchar *) "active",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_manager_signal_info_activated_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_manager_signal_info_activated_ARG_active,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_manager_signal_info_activated =
+{
+  {
+    -1,
+    (gchar *) "Activated",
+    (GDBusArgInfo **) &_net_nfc_gdbus_manager_signal_info_activated_ARG_pointers,
+    NULL
+  },
+  "activated"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_manager_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_manager_signal_info_activated,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_manager_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Manager",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_manager_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_manager_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "manager",
+};
+
+
+/**
+ * net_nfc_gdbus_manager_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_manager_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_manager_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusManager interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_manager_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusManager:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link>.
+ */
+
+/**
+ * NetNfcGDbusManagerIface:
+ * @parent_iface: The parent interface.
+ * @handle_configure_discovery: Handler for the #NetNfcGDbusManager::handle-configure-discovery signal.
+ * @handle_get_server_state: Handler for the #NetNfcGDbusManager::handle-get-server-state signal.
+ * @handle_set_active: Handler for the #NetNfcGDbusManager::handle-set-active signal.
+ * @activated: Handler for the #NetNfcGDbusManager::activated signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link>.
+ */
+
+typedef NetNfcGDbusManagerIface NetNfcGDbusManagerInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusManager, net_nfc_gdbus_manager, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_manager_default_init (NetNfcGDbusManagerIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusManager::handle-set-active:
+   * @object: A #NetNfcGDbusManager.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_is_active: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.SetActive">SetActive()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_manager_complete_set_active() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-active",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusManagerIface, handle_set_active),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN);
+
+  /**
+   * NetNfcGDbusManager::handle-get-server-state:
+   * @object: A #NetNfcGDbusManager.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.GetServerState">GetServerState()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_manager_complete_get_server_state() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-server-state",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusManagerIface, handle_get_server_state),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusManager::handle-configure-discovery:
+   * @object: A #NetNfcGDbusManager.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_mode: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.ConfigureDiscovery">ConfigureDiscovery()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_manager_complete_configure_discovery() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-configure-discovery",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusManagerIface, handle_configure_discovery),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusManager::activated:
+   * @object: A #NetNfcGDbusManager.
+   * @arg_active: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Manager.Activated">"Activated"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("activated",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusManagerIface, activated),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_BOOLEAN);
+
+}
+
+/**
+ * net_nfc_gdbus_manager_emit_activated:
+ * @object: A #NetNfcGDbusManager.
+ * @arg_active: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Manager.Activated">"Activated"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_manager_emit_activated (
+    NetNfcGDbusManager *object,
+    gboolean arg_active)
+{
+  g_signal_emit_by_name (object, "activated", arg_active);
+}
+
+/**
+ * net_nfc_gdbus_manager_call_set_active:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @arg_is_active: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.SetActive">SetActive()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_manager_call_set_active_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_manager_call_set_active_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_manager_call_set_active (
+    NetNfcGDbusManager *proxy,
+    gboolean arg_is_active,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetActive",
+    g_variant_new ("(b)",
+                   arg_is_active),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_manager_call_set_active_finish:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_manager_call_set_active().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_manager_call_set_active().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_set_active_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_call_set_active_sync:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @arg_is_active: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.SetActive">SetActive()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_manager_call_set_active() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_set_active_sync (
+    NetNfcGDbusManager *proxy,
+    gboolean arg_is_active,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetActive",
+    g_variant_new ("(b)",
+                   arg_is_active),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_call_get_server_state:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.GetServerState">GetServerState()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_manager_call_get_server_state_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_manager_call_get_server_state_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_manager_call_get_server_state (
+    NetNfcGDbusManager *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetServerState",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_manager_call_get_server_state_finish:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_state: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_manager_call_get_server_state().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_manager_call_get_server_state().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_get_server_state_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    guint *out_state,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_state);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_call_get_server_state_sync:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_state: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.GetServerState">GetServerState()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_manager_call_get_server_state() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_get_server_state_sync (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    guint *out_state,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetServerState",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_state);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_call_configure_discovery:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.ConfigureDiscovery">ConfigureDiscovery()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_manager_call_configure_discovery_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_manager_call_configure_discovery_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_manager_call_configure_discovery (
+    NetNfcGDbusManager *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ConfigureDiscovery",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_manager_call_configure_discovery_finish:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_manager_call_configure_discovery().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_manager_call_configure_discovery().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_configure_discovery_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_call_configure_discovery_sync:
+ * @proxy: A #NetNfcGDbusManagerProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.ConfigureDiscovery">ConfigureDiscovery()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_manager_call_configure_discovery() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_manager_call_configure_discovery_sync (
+    NetNfcGDbusManager *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ConfigureDiscovery",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_complete_set_active:
+ * @object: A #NetNfcGDbusManager.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.SetActive">SetActive()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_manager_complete_set_active (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_manager_complete_get_server_state:
+ * @object: A #NetNfcGDbusManager.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @state: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.GetServerState">GetServerState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_manager_complete_get_server_state (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint state)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   state));
+}
+
+/**
+ * net_nfc_gdbus_manager_complete_configure_discovery:
+ * @object: A #NetNfcGDbusManager.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Manager.ConfigureDiscovery">ConfigureDiscovery()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_manager_complete_configure_discovery (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusManagerProxy:
+ *
+ * The #NetNfcGDbusManagerProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusManagerProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusManagerProxy.
+ */
+
+struct _NetNfcGDbusManagerProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_manager_proxy_iface_init (NetNfcGDbusManagerIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusManagerProxy, net_nfc_gdbus_manager_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusManagerProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_MANAGER, net_nfc_gdbus_manager_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusManagerProxy, net_nfc_gdbus_manager_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_MANAGER, net_nfc_gdbus_manager_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_manager_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusManagerProxy *proxy = NET_NFC_GDBUS_MANAGER_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_manager_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_manager_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_manager_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_manager_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_MANAGER);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_MANAGER);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_manager_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusManagerProxy *proxy = NET_NFC_GDBUS_MANAGER_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_manager_proxy_init (NetNfcGDbusManagerProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_manager_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_MANAGER_PROXY, NetNfcGDbusManagerProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_manager_interface_info ());
+}
+
+static void
+net_nfc_gdbus_manager_proxy_class_init (NetNfcGDbusManagerProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_manager_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_manager_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_manager_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_manager_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_manager_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusManagerProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_manager_proxy_iface_init (NetNfcGDbusManagerIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_manager_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_manager_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_manager_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_manager_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Manager", NULL);
+}
+
+/**
+ * net_nfc_gdbus_manager_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_manager_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_manager_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusManagerProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusManager *
+net_nfc_gdbus_manager_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_MANAGER (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_manager_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusManagerProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusManager *
+net_nfc_gdbus_manager_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Manager", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_MANAGER (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_manager_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_manager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_manager_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_manager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_manager_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Manager", NULL);
+}
+
+/**
+ * net_nfc_gdbus_manager_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_manager_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_manager_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusManagerProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusManager *
+net_nfc_gdbus_manager_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_MANAGER (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_manager_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_manager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_manager_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusManagerProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusManager *
+net_nfc_gdbus_manager_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Manager", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_MANAGER (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusManagerSkeleton:
+ *
+ * The #NetNfcGDbusManagerSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusManagerSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusManagerSkeleton.
+ */
+
+struct _NetNfcGDbusManagerSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_manager_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_MANAGER);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_MANAGER);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_manager_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_manager_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_manager_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_manager_skeleton_vtable =
+{
+  _net_nfc_gdbus_manager_skeleton_handle_method_call,
+  _net_nfc_gdbus_manager_skeleton_handle_get_property,
+  _net_nfc_gdbus_manager_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_manager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_manager_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_manager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_manager_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_manager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_manager_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_manager_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_manager_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_manager_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Manager", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_manager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_manager_on_signal_activated (
+    NetNfcGDbusManager *object,
+    gboolean arg_active)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(b)",
+                   arg_active));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Manager", "Activated",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_manager_skeleton_iface_init (NetNfcGDbusManagerIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusManagerSkeleton, net_nfc_gdbus_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusManagerSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_MANAGER, net_nfc_gdbus_manager_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusManagerSkeleton, net_nfc_gdbus_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_MANAGER, net_nfc_gdbus_manager_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_manager_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusManagerSkeleton *skeleton = NET_NFC_GDBUS_MANAGER_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_manager_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_manager_skeleton_init (NetNfcGDbusManagerSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_manager_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_MANAGER_SKELETON, NetNfcGDbusManagerSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_manager_skeleton_class_init (NetNfcGDbusManagerSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_manager_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_manager_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_manager_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_manager_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_manager_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusManagerSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_manager_skeleton_iface_init (NetNfcGDbusManagerIface *iface)
+{
+  iface->activated = _net_nfc_gdbus_manager_on_signal_activated;
+}
+
+/**
+ * net_nfc_gdbus_manager_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Manager.top_of_page">org.tizen.NetNfcService.Manager</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusManagerSkeleton): The skeleton object.
+ */
+NetNfcGDbusManager *
+net_nfc_gdbus_manager_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_MANAGER (g_object_new (NET_NFC_GDBUS_TYPE_MANAGER_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Tag
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusTag
+ * @title: NetNfcGDbusTag
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Tag D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Tag ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_is_connected =
+{
+  {
+    -1,
+    (gchar *) "is_connected",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_result,
+  &_net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_is_connected,
+  &_net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_dev_type,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_tag_method_info_is_tag_connected =
+{
+  {
+    -1,
+    (gchar *) "IsTagConnected",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_method_info_is_tag_connected_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-is-tag-connected",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_is_connected =
+{
+  {
+    -1,
+    (gchar *) "is_connected",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_is_ndef_supported =
+{
+  {
+    -1,
+    (gchar *) "is_ndef_supported",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_ndef_card_state =
+{
+  {
+    -1,
+    (gchar *) "ndef_card_state",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_max_data_size =
+{
+  {
+    -1,
+    (gchar *) "max_data_size",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_actual_data_size =
+{
+  {
+    -1,
+    (gchar *) "actual_data_size",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_number_of_keys =
+{
+  {
+    -1,
+    (gchar *) "number_of_keys",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_target_info_values =
+{
+  {
+    -1,
+    (gchar *) "target_info_values",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_raw_data =
+{
+  {
+    -1,
+    (gchar *) "raw_data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_result,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_is_connected,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_handle,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_dev_type,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_is_ndef_supported,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_ndef_card_state,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_max_data_size,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_actual_data_size,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_number_of_keys,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_target_info_values,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_raw_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_tag_method_info_get_current_tag_info =
+{
+  {
+    -1,
+    (gchar *) "GetCurrentTagInfo",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_method_info_get_current_tag_info_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-current-tag-info",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_barcode =
+{
+  {
+    -1,
+    (gchar *) "barcode",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_result,
+  &_net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_barcode,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_tag_method_info_get_barcode =
+{
+  {
+    -1,
+    (gchar *) "GetBarcode",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_method_info_get_barcode_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-barcode",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_is_connected =
+{
+  {
+    -1,
+    (gchar *) "is_connected",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_result,
+  &_net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_is_connected,
+  &_net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_handle,
+  &_net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_dev_type,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_tag_method_info_get_current_target_handle =
+{
+  {
+    -1,
+    (gchar *) "GetCurrentTargetHandle",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_method_info_get_current_target_handle_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-current-target-handle",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_tag_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_tag_method_info_is_tag_connected,
+  &_net_nfc_gdbus_tag_method_info_get_current_tag_info,
+  &_net_nfc_gdbus_tag_method_info_get_barcode,
+  &_net_nfc_gdbus_tag_method_info_get_current_target_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_is_ndef_supported =
+{
+  {
+    -1,
+    (gchar *) "is_ndef_supported",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_ndef_card_state =
+{
+  {
+    -1,
+    (gchar *) "ndef_card_state",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_max_data_size =
+{
+  {
+    -1,
+    (gchar *) "max_data_size",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_actual_data_size =
+{
+  {
+    -1,
+    (gchar *) "actual_data_size",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_number_of_keys =
+{
+  {
+    -1,
+    (gchar *) "number_of_keys",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_target_info_values =
+{
+  {
+    -1,
+    (gchar *) "target_info_values",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_raw_data =
+{
+  {
+    -1,
+    (gchar *) "raw_data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_handle,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_dev_type,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_is_ndef_supported,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_ndef_card_state,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_max_data_size,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_actual_data_size,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_number_of_keys,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_target_info_values,
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_raw_data,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_tag_signal_info_tag_discovered =
+{
+  {
+    -1,
+    (gchar *) "TagDiscovered",
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_signal_info_tag_discovered_ARG_pointers,
+    NULL
+  },
+  "tag-discovered"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_detached_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_tag_signal_info_tag_detached_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_tag_signal_info_tag_detached_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_tag_signal_info_tag_detached_ARG_handle,
+  &_net_nfc_gdbus_tag_signal_info_tag_detached_ARG_dev_type,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_tag_signal_info_tag_detached =
+{
+  {
+    -1,
+    (gchar *) "TagDetached",
+    (GDBusArgInfo **) &_net_nfc_gdbus_tag_signal_info_tag_detached_ARG_pointers,
+    NULL
+  },
+  "tag-detached"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_tag_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_tag_signal_info_tag_discovered,
+  &_net_nfc_gdbus_tag_signal_info_tag_detached,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_tag_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Tag",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_tag_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_tag_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "tag",
+};
+
+
+/**
+ * net_nfc_gdbus_tag_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_tag_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_tag_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusTag interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_tag_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusTag:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link>.
+ */
+
+/**
+ * NetNfcGDbusTagIface:
+ * @parent_iface: The parent interface.
+ * @handle_get_barcode: Handler for the #NetNfcGDbusTag::handle-get-barcode signal.
+ * @handle_get_current_tag_info: Handler for the #NetNfcGDbusTag::handle-get-current-tag-info signal.
+ * @handle_get_current_target_handle: Handler for the #NetNfcGDbusTag::handle-get-current-target-handle signal.
+ * @handle_is_tag_connected: Handler for the #NetNfcGDbusTag::handle-is-tag-connected signal.
+ * @tag_detached: Handler for the #NetNfcGDbusTag::tag-detached signal.
+ * @tag_discovered: Handler for the #NetNfcGDbusTag::tag-discovered signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link>.
+ */
+
+typedef NetNfcGDbusTagIface NetNfcGDbusTagInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusTag, net_nfc_gdbus_tag, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_tag_default_init (NetNfcGDbusTagIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusTag::handle-is-tag-connected:
+   * @object: A #NetNfcGDbusTag.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.IsTagConnected">IsTagConnected()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_tag_complete_is_tag_connected() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-is-tag-connected",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, handle_is_tag_connected),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTag::handle-get-current-tag-info:
+   * @object: A #NetNfcGDbusTag.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTagInfo">GetCurrentTagInfo()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_tag_complete_get_current_tag_info() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-current-tag-info",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, handle_get_current_tag_info),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTag::handle-get-barcode:
+   * @object: A #NetNfcGDbusTag.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetBarcode">GetBarcode()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_tag_complete_get_barcode() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-barcode",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, handle_get_barcode),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTag::handle-get-current-target-handle:
+   * @object: A #NetNfcGDbusTag.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTargetHandle">GetCurrentTargetHandle()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_tag_complete_get_current_target_handle() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-current-target-handle",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, handle_get_current_target_handle),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusTag::tag-discovered:
+   * @object: A #NetNfcGDbusTag.
+   * @arg_handle: Argument.
+   * @arg_dev_type: Argument.
+   * @arg_is_ndef_supported: Argument.
+   * @arg_ndef_card_state: Argument.
+   * @arg_max_data_size: Argument.
+   * @arg_actual_data_size: Argument.
+   * @arg_number_of_keys: Argument.
+   * @arg_target_info_values: Argument.
+   * @arg_raw_data: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Tag.TagDiscovered">"TagDiscovered"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("tag-discovered",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, tag_discovered),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    9, G_TYPE_UINT, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_UCHAR, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusTag::tag-detached:
+   * @object: A #NetNfcGDbusTag.
+   * @arg_handle: Argument.
+   * @arg_dev_type: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Tag.TagDetached">"TagDetached"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("tag-detached",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTagIface, tag_detached),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    2, G_TYPE_UINT, G_TYPE_INT);
+
+}
+
+/**
+ * net_nfc_gdbus_tag_emit_tag_discovered:
+ * @object: A #NetNfcGDbusTag.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_dev_type: Argument to pass with the signal.
+ * @arg_is_ndef_supported: Argument to pass with the signal.
+ * @arg_ndef_card_state: Argument to pass with the signal.
+ * @arg_max_data_size: Argument to pass with the signal.
+ * @arg_actual_data_size: Argument to pass with the signal.
+ * @arg_number_of_keys: Argument to pass with the signal.
+ * @arg_target_info_values: Argument to pass with the signal.
+ * @arg_raw_data: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Tag.TagDiscovered">"TagDiscovered"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_tag_emit_tag_discovered (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type,
+    gboolean arg_is_ndef_supported,
+    guchar arg_ndef_card_state,
+    guint arg_max_data_size,
+    guint arg_actual_data_size,
+    guint arg_number_of_keys,
+    GVariant *arg_target_info_values,
+    GVariant *arg_raw_data)
+{
+  g_signal_emit_by_name (object, "tag-discovered", arg_handle, arg_dev_type, arg_is_ndef_supported, arg_ndef_card_state, arg_max_data_size, arg_actual_data_size, arg_number_of_keys, arg_target_info_values, arg_raw_data);
+}
+
+/**
+ * net_nfc_gdbus_tag_emit_tag_detached:
+ * @object: A #NetNfcGDbusTag.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_dev_type: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Tag.TagDetached">"TagDetached"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_tag_emit_tag_detached (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type)
+{
+  g_signal_emit_by_name (object, "tag-detached", arg_handle, arg_dev_type);
+}
+
+/**
+ * net_nfc_gdbus_tag_call_is_tag_connected:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.IsTagConnected">IsTagConnected()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_call_is_tag_connected_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_call_is_tag_connected_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_tag_call_is_tag_connected (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "IsTagConnected",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_tag_call_is_tag_connected_finish:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_call_is_tag_connected().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_call_is_tag_connected().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_is_tag_connected_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    gint *out_dev_type,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibi)",
+                 out_result,
+                 out_is_connected,
+                 out_dev_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_is_tag_connected_sync:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.IsTagConnected">IsTagConnected()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_call_is_tag_connected() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_is_tag_connected_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    gint *out_dev_type,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "IsTagConnected",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibi)",
+                 out_result,
+                 out_is_connected,
+                 out_dev_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_tag_info:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTagInfo">GetCurrentTagInfo()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_call_get_current_tag_info_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_call_get_current_tag_info_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_tag_call_get_current_tag_info (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetCurrentTagInfo",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_tag_info_finish:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_ndef_supported: (out): Return location for return parameter or %NULL to ignore.
+ * @out_ndef_card_state: (out): Return location for return parameter or %NULL to ignore.
+ * @out_max_data_size: (out): Return location for return parameter or %NULL to ignore.
+ * @out_actual_data_size: (out): Return location for return parameter or %NULL to ignore.
+ * @out_number_of_keys: (out): Return location for return parameter or %NULL to ignore.
+ * @out_target_info_values: (out): Return location for return parameter or %NULL to ignore.
+ * @out_raw_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_call_get_current_tag_info().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_call_get_current_tag_info().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_current_tag_info_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    gboolean *out_is_ndef_supported,
+    guchar *out_ndef_card_state,
+    guint *out_max_data_size,
+    guint *out_actual_data_size,
+    guint *out_number_of_keys,
+    GVariant **out_target_info_values,
+    GVariant **out_raw_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibuibyuuu@a(y)@a(y))",
+                 out_result,
+                 out_is_connected,
+                 out_handle,
+                 out_dev_type,
+                 out_is_ndef_supported,
+                 out_ndef_card_state,
+                 out_max_data_size,
+                 out_actual_data_size,
+                 out_number_of_keys,
+                 out_target_info_values,
+                 out_raw_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_tag_info_sync:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_ndef_supported: (out): Return location for return parameter or %NULL to ignore.
+ * @out_ndef_card_state: (out): Return location for return parameter or %NULL to ignore.
+ * @out_max_data_size: (out): Return location for return parameter or %NULL to ignore.
+ * @out_actual_data_size: (out): Return location for return parameter or %NULL to ignore.
+ * @out_number_of_keys: (out): Return location for return parameter or %NULL to ignore.
+ * @out_target_info_values: (out): Return location for return parameter or %NULL to ignore.
+ * @out_raw_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTagInfo">GetCurrentTagInfo()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_call_get_current_tag_info() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_current_tag_info_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    gboolean *out_is_ndef_supported,
+    guchar *out_ndef_card_state,
+    guint *out_max_data_size,
+    guint *out_actual_data_size,
+    guint *out_number_of_keys,
+    GVariant **out_target_info_values,
+    GVariant **out_raw_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetCurrentTagInfo",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibuibyuuu@a(y)@a(y))",
+                 out_result,
+                 out_is_connected,
+                 out_handle,
+                 out_dev_type,
+                 out_is_ndef_supported,
+                 out_ndef_card_state,
+                 out_max_data_size,
+                 out_actual_data_size,
+                 out_number_of_keys,
+                 out_target_info_values,
+                 out_raw_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_barcode:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetBarcode">GetBarcode()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_call_get_barcode_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_call_get_barcode_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_tag_call_get_barcode (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetBarcode",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_barcode_finish:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_barcode: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_call_get_barcode().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_call_get_barcode().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_barcode_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    GVariant **out_barcode,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_barcode);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_barcode_sync:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_barcode: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetBarcode">GetBarcode()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_call_get_barcode() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_barcode_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    GVariant **out_barcode,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetBarcode",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_barcode);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_target_handle:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTargetHandle">GetCurrentTargetHandle()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_call_get_current_target_handle_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_call_get_current_target_handle_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_tag_call_get_current_target_handle (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetCurrentTargetHandle",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_target_handle_finish:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_call_get_current_target_handle().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_call_get_current_target_handle().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_current_target_handle_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibui)",
+                 out_result,
+                 out_is_connected,
+                 out_handle,
+                 out_dev_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_call_get_current_target_handle_sync:
+ * @proxy: A #NetNfcGDbusTagProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_is_connected: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @out_dev_type: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTargetHandle">GetCurrentTargetHandle()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_call_get_current_target_handle() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_tag_call_get_current_target_handle_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetCurrentTargetHandle",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ibui)",
+                 out_result,
+                 out_is_connected,
+                 out_handle,
+                 out_dev_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_complete_is_tag_connected:
+ * @object: A #NetNfcGDbusTag.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @is_connected: Parameter to return.
+ * @dev_type: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.IsTagConnected">IsTagConnected()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_tag_complete_is_tag_connected (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    gint dev_type)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ibi)",
+                   result,
+                   is_connected,
+                   dev_type));
+}
+
+/**
+ * net_nfc_gdbus_tag_complete_get_current_tag_info:
+ * @object: A #NetNfcGDbusTag.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @is_connected: Parameter to return.
+ * @handle: Parameter to return.
+ * @dev_type: Parameter to return.
+ * @is_ndef_supported: Parameter to return.
+ * @ndef_card_state: Parameter to return.
+ * @max_data_size: Parameter to return.
+ * @actual_data_size: Parameter to return.
+ * @number_of_keys: Parameter to return.
+ * @target_info_values: Parameter to return.
+ * @raw_data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTagInfo">GetCurrentTagInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_tag_complete_get_current_tag_info (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    guint handle,
+    gint dev_type,
+    gboolean is_ndef_supported,
+    guchar ndef_card_state,
+    guint max_data_size,
+    guint actual_data_size,
+    guint number_of_keys,
+    GVariant *target_info_values,
+    GVariant *raw_data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ibuibyuuu@a(y)@a(y))",
+                   result,
+                   is_connected,
+                   handle,
+                   dev_type,
+                   is_ndef_supported,
+                   ndef_card_state,
+                   max_data_size,
+                   actual_data_size,
+                   number_of_keys,
+                   target_info_values,
+                   raw_data));
+}
+
+/**
+ * net_nfc_gdbus_tag_complete_get_barcode:
+ * @object: A #NetNfcGDbusTag.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @barcode: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetBarcode">GetBarcode()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_tag_complete_get_barcode (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *barcode)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   barcode));
+}
+
+/**
+ * net_nfc_gdbus_tag_complete_get_current_target_handle:
+ * @object: A #NetNfcGDbusTag.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @is_connected: Parameter to return.
+ * @handle: Parameter to return.
+ * @dev_type: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Tag.GetCurrentTargetHandle">GetCurrentTargetHandle()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_tag_complete_get_current_target_handle (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    guint handle,
+    gint dev_type)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ibui)",
+                   result,
+                   is_connected,
+                   handle,
+                   dev_type));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTagProxy:
+ *
+ * The #NetNfcGDbusTagProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTagProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTagProxy.
+ */
+
+struct _NetNfcGDbusTagProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_tag_proxy_iface_init (NetNfcGDbusTagIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTagProxy, net_nfc_gdbus_tag_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusTagProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TAG, net_nfc_gdbus_tag_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTagProxy, net_nfc_gdbus_tag_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TAG, net_nfc_gdbus_tag_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_tag_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusTagProxy *proxy = NET_NFC_GDBUS_TAG_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_tag_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_tag_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_tag_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_tag_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_TAG);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TAG);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_tag_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusTagProxy *proxy = NET_NFC_GDBUS_TAG_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_tag_proxy_init (NetNfcGDbusTagProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_tag_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_TAG_PROXY, NetNfcGDbusTagProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_tag_interface_info ());
+}
+
+static void
+net_nfc_gdbus_tag_proxy_class_init (NetNfcGDbusTagProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_tag_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_tag_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_tag_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_tag_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_tag_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTagProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_tag_proxy_iface_init (NetNfcGDbusTagIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_tag_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_tag_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TAG_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Tag", NULL);
+}
+
+/**
+ * net_nfc_gdbus_tag_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTagProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTag *
+net_nfc_gdbus_tag_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TAG (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTagProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTag *
+net_nfc_gdbus_tag_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TAG_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Tag", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TAG (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_tag_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_tag_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_tag_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_tag_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_tag_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TAG_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Tag", NULL);
+}
+
+/**
+ * net_nfc_gdbus_tag_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_tag_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_tag_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTagProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTag *
+net_nfc_gdbus_tag_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TAG (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_tag_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_tag_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_tag_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTagProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTag *
+net_nfc_gdbus_tag_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TAG_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Tag", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TAG (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTagSkeleton:
+ *
+ * The #NetNfcGDbusTagSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTagSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTagSkeleton.
+ */
+
+struct _NetNfcGDbusTagSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_tag_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_TAG);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TAG);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_tag_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_tag_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_tag_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_tag_skeleton_vtable =
+{
+  _net_nfc_gdbus_tag_skeleton_handle_method_call,
+  _net_nfc_gdbus_tag_skeleton_handle_get_property,
+  _net_nfc_gdbus_tag_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_tag_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_tag_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_tag_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_tag_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_tag_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_tag_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_tag_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_tag_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_tag_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Tag", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_tag_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_tag_on_signal_tag_discovered (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type,
+    gboolean arg_is_ndef_supported,
+    guchar arg_ndef_card_state,
+    guint arg_max_data_size,
+    guint arg_actual_data_size,
+    guint arg_number_of_keys,
+    GVariant *arg_target_info_values,
+    GVariant *arg_raw_data)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(uibyuuu@a(y)@a(y))",
+                   arg_handle,
+                   arg_dev_type,
+                   arg_is_ndef_supported,
+                   arg_ndef_card_state,
+                   arg_max_data_size,
+                   arg_actual_data_size,
+                   arg_number_of_keys,
+                   arg_target_info_values,
+                   arg_raw_data));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Tag", "TagDiscovered",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_tag_on_signal_tag_detached (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(ui)",
+                   arg_handle,
+                   arg_dev_type));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Tag", "TagDetached",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_tag_skeleton_iface_init (NetNfcGDbusTagIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTagSkeleton, net_nfc_gdbus_tag_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusTagSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TAG, net_nfc_gdbus_tag_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTagSkeleton, net_nfc_gdbus_tag_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TAG, net_nfc_gdbus_tag_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_tag_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusTagSkeleton *skeleton = NET_NFC_GDBUS_TAG_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_tag_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_tag_skeleton_init (NetNfcGDbusTagSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_tag_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_TAG_SKELETON, NetNfcGDbusTagSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_tag_skeleton_class_init (NetNfcGDbusTagSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_tag_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_tag_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_tag_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_tag_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_tag_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTagSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_tag_skeleton_iface_init (NetNfcGDbusTagIface *iface)
+{
+  iface->tag_discovered = _net_nfc_gdbus_tag_on_signal_tag_discovered;
+  iface->tag_detached = _net_nfc_gdbus_tag_on_signal_tag_detached;
+}
+
+/**
+ * net_nfc_gdbus_tag_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Tag.top_of_page">org.tizen.NetNfcService.Tag</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTagSkeleton): The skeleton object.
+ */
+NetNfcGDbusTag *
+net_nfc_gdbus_tag_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_TAG (g_object_new (NET_NFC_GDBUS_TYPE_TAG_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Ndef
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusNdef
+ * @title: NetNfcGDbusNdef
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Ndef D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Ndef ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_read_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_read_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_read_IN_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_read_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_read_OUT_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_read_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_read_OUT_ARG_result,
+  &_net_nfc_gdbus_ndef_method_info_read_OUT_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_ndef_method_info_read =
+{
+  {
+    -1,
+    (gchar *) "Read",
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_read_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_read_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-read",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_write_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_write_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_write_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_write_IN_ARG_handle,
+  &_net_nfc_gdbus_ndef_method_info_write_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_write_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_write_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_write_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_ndef_method_info_write =
+{
+  {
+    -1,
+    (gchar *) "Write",
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_write_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_write_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-write",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_make_read_only_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_make_read_only_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_make_read_only_IN_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_make_read_only_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_make_read_only_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_make_read_only_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_ndef_method_info_make_read_only =
+{
+  {
+    -1,
+    (gchar *) "MakeReadOnly",
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_make_read_only_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_make_read_only_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-make-read-only",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_format_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_format_IN_ARG_key =
+{
+  {
+    -1,
+    (gchar *) "key",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_format_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_format_IN_ARG_handle,
+  &_net_nfc_gdbus_ndef_method_info_format_IN_ARG_key,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_ndef_method_info_format_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_ndef_method_info_format_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_format_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_ndef_method_info_format =
+{
+  {
+    -1,
+    (gchar *) "Format",
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_format_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_ndef_method_info_format_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-format",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_ndef_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_ndef_method_info_read,
+  &_net_nfc_gdbus_ndef_method_info_write,
+  &_net_nfc_gdbus_ndef_method_info_make_read_only,
+  &_net_nfc_gdbus_ndef_method_info_format,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_ndef_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Ndef",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_ndef_method_info_pointers,
+    NULL,
+    NULL,
+    NULL
+  },
+  "ndef",
+};
+
+
+/**
+ * net_nfc_gdbus_ndef_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_ndef_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_ndef_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusNdef interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_ndef_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusNdef:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link>.
+ */
+
+/**
+ * NetNfcGDbusNdefIface:
+ * @parent_iface: The parent interface.
+ * @handle_format: Handler for the #NetNfcGDbusNdef::handle-format signal.
+ * @handle_make_read_only: Handler for the #NetNfcGDbusNdef::handle-make-read-only signal.
+ * @handle_read: Handler for the #NetNfcGDbusNdef::handle-read signal.
+ * @handle_write: Handler for the #NetNfcGDbusNdef::handle-write signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link>.
+ */
+
+typedef NetNfcGDbusNdefIface NetNfcGDbusNdefInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusNdef, net_nfc_gdbus_ndef, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_ndef_default_init (NetNfcGDbusNdefIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusNdef::handle-read:
+   * @object: A #NetNfcGDbusNdef.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Read">Read()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_ndef_complete_read() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-read",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusNdefIface, handle_read),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusNdef::handle-write:
+   * @object: A #NetNfcGDbusNdef.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Write">Write()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_ndef_complete_write() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-write",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusNdefIface, handle_write),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusNdef::handle-make-read-only:
+   * @object: A #NetNfcGDbusNdef.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.MakeReadOnly">MakeReadOnly()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_ndef_complete_make_read_only() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-make-read-only",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusNdefIface, handle_make_read_only),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusNdef::handle-format:
+   * @object: A #NetNfcGDbusNdef.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_key: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Format">Format()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_ndef_complete_format() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-format",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusNdefIface, handle_format),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);
+
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_read:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Read">Read()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_call_read_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_call_read_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_ndef_call_read (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Read",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_read_finish:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_call_read().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_call_read().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_read_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_read_sync:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Read">Read()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_call_read() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_read_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Read",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_write:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Write">Write()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_call_write_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_call_write_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_ndef_call_write (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Write",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_write_finish:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_call_write().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_call_write().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_write_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_write_sync:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Write">Write()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_call_write() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_write_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Write",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_make_read_only:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.MakeReadOnly">MakeReadOnly()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_call_make_read_only_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_call_make_read_only_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_ndef_call_make_read_only (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "MakeReadOnly",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_make_read_only_finish:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_call_make_read_only().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_call_make_read_only().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_make_read_only_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_make_read_only_sync:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.MakeReadOnly">MakeReadOnly()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_call_make_read_only() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_make_read_only_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "MakeReadOnly",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_format:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_key: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Format">Format()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_call_format_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_call_format_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_ndef_call_format (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_key,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Format",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_key),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_format_finish:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_call_format().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_call_format().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_format_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_call_format_sync:
+ * @proxy: A #NetNfcGDbusNdefProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_key: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Format">Format()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_call_format() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_ndef_call_format_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_key,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Format",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_key),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_complete_read:
+ * @object: A #NetNfcGDbusNdef.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Read">Read()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_ndef_complete_read (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   data));
+}
+
+/**
+ * net_nfc_gdbus_ndef_complete_write:
+ * @object: A #NetNfcGDbusNdef.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Write">Write()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_ndef_complete_write (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_ndef_complete_make_read_only:
+ * @object: A #NetNfcGDbusNdef.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.MakeReadOnly">MakeReadOnly()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_ndef_complete_make_read_only (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_ndef_complete_format:
+ * @object: A #NetNfcGDbusNdef.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Ndef.Format">Format()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_ndef_complete_format (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusNdefProxy:
+ *
+ * The #NetNfcGDbusNdefProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusNdefProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusNdefProxy.
+ */
+
+struct _NetNfcGDbusNdefProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_ndef_proxy_iface_init (NetNfcGDbusNdefIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusNdefProxy, net_nfc_gdbus_ndef_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusNdefProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_NDEF, net_nfc_gdbus_ndef_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusNdefProxy, net_nfc_gdbus_ndef_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_NDEF, net_nfc_gdbus_ndef_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_ndef_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusNdefProxy *proxy = NET_NFC_GDBUS_NDEF_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_ndef_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_NDEF);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_NDEF);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusNdefProxy *proxy = NET_NFC_GDBUS_NDEF_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_init (NetNfcGDbusNdefProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_ndef_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_NDEF_PROXY, NetNfcGDbusNdefProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_ndef_interface_info ());
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_class_init (NetNfcGDbusNdefProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_ndef_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_ndef_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_ndef_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_ndef_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_ndef_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusNdefProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_ndef_proxy_iface_init (NetNfcGDbusNdefIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_ndef_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_NDEF_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Ndef", NULL);
+}
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusNdefProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusNdef *
+net_nfc_gdbus_ndef_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_NDEF (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusNdefProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusNdef *
+net_nfc_gdbus_ndef_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_NDEF_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Ndef", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_NDEF (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_ndef_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_ndef_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_ndef_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_ndef_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_NDEF_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Ndef", NULL);
+}
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_ndef_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_ndef_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusNdefProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusNdef *
+net_nfc_gdbus_ndef_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_NDEF (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_ndef_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_ndef_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_ndef_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusNdefProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusNdef *
+net_nfc_gdbus_ndef_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_NDEF_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Ndef", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_NDEF (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusNdefSkeleton:
+ *
+ * The #NetNfcGDbusNdefSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusNdefSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusNdefSkeleton.
+ */
+
+struct _NetNfcGDbusNdefSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_ndef_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusNdefSkeleton *skeleton = NET_NFC_GDBUS_NDEF_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_NDEF);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_NDEF);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_ndef_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusNdefSkeleton *skeleton = NET_NFC_GDBUS_NDEF_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_ndef_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusNdefSkeleton *skeleton = NET_NFC_GDBUS_NDEF_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_ndef_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_ndef_skeleton_vtable =
+{
+  _net_nfc_gdbus_ndef_skeleton_handle_method_call,
+  _net_nfc_gdbus_ndef_skeleton_handle_get_property,
+  _net_nfc_gdbus_ndef_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_ndef_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_ndef_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_ndef_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_ndef_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_ndef_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusNdefSkeleton *skeleton = NET_NFC_GDBUS_NDEF_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_ndef_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_ndef_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_ndef_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_ndef_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Ndef", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_ndef_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void net_nfc_gdbus_ndef_skeleton_iface_init (NetNfcGDbusNdefIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusNdefSkeleton, net_nfc_gdbus_ndef_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusNdefSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_NDEF, net_nfc_gdbus_ndef_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusNdefSkeleton, net_nfc_gdbus_ndef_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_NDEF, net_nfc_gdbus_ndef_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_ndef_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusNdefSkeleton *skeleton = NET_NFC_GDBUS_NDEF_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_ndef_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_ndef_skeleton_init (NetNfcGDbusNdefSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_ndef_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_NDEF_SKELETON, NetNfcGDbusNdefSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_ndef_skeleton_class_init (NetNfcGDbusNdefSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_ndef_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_ndef_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_ndef_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_ndef_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_ndef_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusNdefSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_ndef_skeleton_iface_init (NetNfcGDbusNdefIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_ndef_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Ndef.top_of_page">org.tizen.NetNfcService.Ndef</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusNdefSkeleton): The skeleton object.
+ */
+NetNfcGDbusNdef *
+net_nfc_gdbus_ndef_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_NDEF (g_object_new (NET_NFC_GDBUS_TYPE_NDEF_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Llcp
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusLlcp
+ * @title: NetNfcGDbusLlcp
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Llcp D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Llcp ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_config_IN_ARG_config =
+{
+  {
+    -1,
+    (gchar *) "config",
+    (gchar *) "(qqyy)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_config_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_config_IN_ARG_config,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_config_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_config_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_config_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_config =
+{
+  {
+    -1,
+    (gchar *) "Config",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_config_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_config_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-config",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_miu =
+{
+  {
+    -1,
+    (gchar *) "miu",
+    (gchar *) "q",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_rw =
+{
+  {
+    -1,
+    (gchar *) "rw",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_service_name =
+{
+  {
+    -1,
+    (gchar *) "service_name",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_listen_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_miu,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_rw,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_type,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_sap,
+  &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_service_name,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_listen =
+{
+  {
+    -1,
+    (gchar *) "Listen",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_listen_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_listen_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-listen",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_accept_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_accept_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_accept_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_accept_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_accept_IN_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_accept_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_accept_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_accept_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_accept =
+{
+  {
+    -1,
+    (gchar *) "Accept",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_accept_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_accept_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-accept",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_reject_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_reject_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_reject_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_reject_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_reject_IN_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_reject_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_reject_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_reject_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_reject =
+{
+  {
+    -1,
+    (gchar *) "Reject",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_reject_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_reject_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-reject",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_miu =
+{
+  {
+    -1,
+    (gchar *) "miu",
+    (gchar *) "q",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_rw =
+{
+  {
+    -1,
+    (gchar *) "rw",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_service_name =
+{
+  {
+    -1,
+    (gchar *) "service_name",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_connect_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_miu,
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_rw,
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_type,
+  &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_service_name,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_connect =
+{
+  {
+    -1,
+    (gchar *) "Connect",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_connect_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_connect_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-connect",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_miu =
+{
+  {
+    -1,
+    (gchar *) "miu",
+    (gchar *) "q",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_rw =
+{
+  {
+    -1,
+    (gchar *) "rw",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_miu,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_rw,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_type,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_sap,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_connect_sap =
+{
+  {
+    -1,
+    (gchar *) "ConnectSap",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_connect_sap_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_connect_sap_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-connect-sap",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_send_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_send_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_send_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_send_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_send_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_send_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_send_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_send =
+{
+  {
+    -1,
+    (gchar *) "Send",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_send_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_send_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-send",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_sap,
+  &_net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_send_to =
+{
+  {
+    -1,
+    (gchar *) "SendTo",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_send_to_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_send_to_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-send-to",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_IN_ARG_request_length =
+{
+  {
+    -1,
+    (gchar *) "request_length",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_receive_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_receive_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_receive_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_receive_IN_ARG_request_length,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_receive =
+{
+  {
+    -1,
+    (gchar *) "Receive",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_receive_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_receive_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-receive",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_request_length =
+{
+  {
+    -1,
+    (gchar *) "request_length",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_request_length,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "y",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_sap,
+  &_net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_receive_from =
+{
+  {
+    -1,
+    (gchar *) "ReceiveFrom",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_receive_from_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_receive_from_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-receive-from",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_close_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_close_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_close_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_close_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_close_IN_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_close_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_close_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_close_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_close_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_close_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_close =
+{
+  {
+    -1,
+    (gchar *) "Close",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_close_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_close_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-close",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_handle,
+  &_net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_result,
+  &_net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_client_socket,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_llcp_method_info_disconnect =
+{
+  {
+    -1,
+    (gchar *) "Disconnect",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_disconnect_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_method_info_disconnect_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-disconnect",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_llcp_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_method_info_config,
+  &_net_nfc_gdbus_llcp_method_info_listen,
+  &_net_nfc_gdbus_llcp_method_info_accept,
+  &_net_nfc_gdbus_llcp_method_info_reject,
+  &_net_nfc_gdbus_llcp_method_info_connect,
+  &_net_nfc_gdbus_llcp_method_info_connect_sap,
+  &_net_nfc_gdbus_llcp_method_info_send,
+  &_net_nfc_gdbus_llcp_method_info_send_to,
+  &_net_nfc_gdbus_llcp_method_info_receive,
+  &_net_nfc_gdbus_llcp_method_info_receive_from,
+  &_net_nfc_gdbus_llcp_method_info_close,
+  &_net_nfc_gdbus_llcp_method_info_disconnect,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_error_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_error_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_error_ARG_error =
+{
+  {
+    -1,
+    (gchar *) "error",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_signal_info_error_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_signal_info_error_ARG_handle,
+  &_net_nfc_gdbus_llcp_signal_info_error_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_signal_info_error_ARG_error,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_llcp_signal_info_error =
+{
+  {
+    -1,
+    (gchar *) "Error",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_signal_info_error_ARG_pointers,
+    NULL
+  },
+  "error"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_incoming_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_incoming_ARG_client_socket =
+{
+  {
+    -1,
+    (gchar *) "client_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_llcp_signal_info_incoming_ARG_incoming_socket =
+{
+  {
+    -1,
+    (gchar *) "incoming_socket",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_llcp_signal_info_incoming_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_signal_info_incoming_ARG_handle,
+  &_net_nfc_gdbus_llcp_signal_info_incoming_ARG_client_socket,
+  &_net_nfc_gdbus_llcp_signal_info_incoming_ARG_incoming_socket,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_llcp_signal_info_incoming =
+{
+  {
+    -1,
+    (gchar *) "Incoming",
+    (GDBusArgInfo **) &_net_nfc_gdbus_llcp_signal_info_incoming_ARG_pointers,
+    NULL
+  },
+  "incoming"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_llcp_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_llcp_signal_info_error,
+  &_net_nfc_gdbus_llcp_signal_info_incoming,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_llcp_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Llcp",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_llcp_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_llcp_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "llcp",
+};
+
+
+/**
+ * net_nfc_gdbus_llcp_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_llcp_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_llcp_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusLlcp interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_llcp_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusLlcp:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link>.
+ */
+
+/**
+ * NetNfcGDbusLlcpIface:
+ * @parent_iface: The parent interface.
+ * @handle_accept: Handler for the #NetNfcGDbusLlcp::handle-accept signal.
+ * @handle_close: Handler for the #NetNfcGDbusLlcp::handle-close signal.
+ * @handle_config: Handler for the #NetNfcGDbusLlcp::handle-config signal.
+ * @handle_connect: Handler for the #NetNfcGDbusLlcp::handle-connect signal.
+ * @handle_connect_sap: Handler for the #NetNfcGDbusLlcp::handle-connect-sap signal.
+ * @handle_disconnect: Handler for the #NetNfcGDbusLlcp::handle-disconnect signal.
+ * @handle_listen: Handler for the #NetNfcGDbusLlcp::handle-listen signal.
+ * @handle_receive: Handler for the #NetNfcGDbusLlcp::handle-receive signal.
+ * @handle_receive_from: Handler for the #NetNfcGDbusLlcp::handle-receive-from signal.
+ * @handle_reject: Handler for the #NetNfcGDbusLlcp::handle-reject signal.
+ * @handle_send: Handler for the #NetNfcGDbusLlcp::handle-send signal.
+ * @handle_send_to: Handler for the #NetNfcGDbusLlcp::handle-send-to signal.
+ * @error: Handler for the #NetNfcGDbusLlcp::error signal.
+ * @incoming: Handler for the #NetNfcGDbusLlcp::incoming signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link>.
+ */
+
+typedef NetNfcGDbusLlcpIface NetNfcGDbusLlcpInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusLlcp, net_nfc_gdbus_llcp, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_llcp_default_init (NetNfcGDbusLlcpIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusLlcp::handle-config:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_config: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Config">Config()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_config() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-config",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_config),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-listen:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_miu: Argument passed by remote caller.
+   * @arg_rw: Argument passed by remote caller.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_service_name: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Listen">Listen()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_listen() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-listen",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_listen),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    8,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_UCHAR, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusLlcp::handle-accept:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Accept">Accept()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_accept() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-accept",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_accept),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-reject:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Reject">Reject()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_reject() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-reject",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_reject),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-connect:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_miu: Argument passed by remote caller.
+   * @arg_rw: Argument passed by remote caller.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_service_name: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Connect">Connect()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_connect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-connect",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_connect),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    7,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusLlcp::handle-connect-sap:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_miu: Argument passed by remote caller.
+   * @arg_rw: Argument passed by remote caller.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_sap: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ConnectSap">ConnectSap()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_connect_sap() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-connect-sap",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_connect_sap),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    7,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_UCHAR);
+
+  /**
+   * NetNfcGDbusLlcp::handle-send:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Send">Send()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_send() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-send",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_send),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-send-to:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.SendTo">SendTo()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_send_to() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-send-to",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_send_to),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    5,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UCHAR, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-receive:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_request_length: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Receive">Receive()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_receive() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-receive",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_receive),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-receive-from:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   * @arg_request_length: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ReceiveFrom">ReceiveFrom()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_receive_from() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-receive-from",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_receive_from),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-close:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Close">Close()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_close() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-close",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_close),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusLlcp::handle-disconnect:
+   * @object: A #NetNfcGDbusLlcp.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_client_socket: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Disconnect">Disconnect()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_llcp_complete_disconnect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-disconnect",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, handle_disconnect),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusLlcp::error:
+   * @object: A #NetNfcGDbusLlcp.
+   * @arg_handle: Argument.
+   * @arg_client_socket: Argument.
+   * @arg_error: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Llcp.Error">"Error"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("error",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, error),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusLlcp::incoming:
+   * @object: A #NetNfcGDbusLlcp.
+   * @arg_handle: Argument.
+   * @arg_client_socket: Argument.
+   * @arg_incoming_socket: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Llcp.Incoming">"Incoming"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("incoming",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusLlcpIface, incoming),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+}
+
+/**
+ * net_nfc_gdbus_llcp_emit_error:
+ * @object: A #NetNfcGDbusLlcp.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_client_socket: Argument to pass with the signal.
+ * @arg_error: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Llcp.Error">"Error"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_llcp_emit_error (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint arg_error)
+{
+  g_signal_emit_by_name (object, "error", arg_handle, arg_client_socket, arg_error);
+}
+
+/**
+ * net_nfc_gdbus_llcp_emit_incoming:
+ * @object: A #NetNfcGDbusLlcp.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_client_socket: Argument to pass with the signal.
+ * @arg_incoming_socket: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Llcp.Incoming">"Incoming"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_llcp_emit_incoming (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_incoming_socket)
+{
+  g_signal_emit_by_name (object, "incoming", arg_handle, arg_client_socket, arg_incoming_socket);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_config:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_config: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Config">Config()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_config_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_config_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_config (
+    NetNfcGDbusLlcp *proxy,
+    GVariant *arg_config,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Config",
+    g_variant_new ("(@(qqyy))",
+                   arg_config),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_config_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_config().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_config().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_config_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_config_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_config: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Config">Config()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_config() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_config_sync (
+    NetNfcGDbusLlcp *proxy,
+    GVariant *arg_config,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Config",
+    g_variant_new ("(@(qqyy))",
+                   arg_config),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_listen:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_service_name: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Listen">Listen()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_listen_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_listen_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_listen (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    const gchar *arg_service_name,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Listen",
+    g_variant_new ("(uuqyiys)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_sap,
+                   arg_service_name),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_listen_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_listen().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_listen().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_listen_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_listen_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_service_name: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Listen">Listen()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_listen() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_listen_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    const gchar *arg_service_name,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Listen",
+    g_variant_new ("(uuqyiys)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_sap,
+                   arg_service_name),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_accept:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Accept">Accept()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_accept_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_accept_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_accept (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Accept",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_accept_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_accept().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_accept().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_accept_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_accept_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Accept">Accept()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_accept() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_accept_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Accept",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_reject:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Reject">Reject()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_reject_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_reject_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_reject (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Reject",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_reject_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_reject().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_reject().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_reject_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_reject_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Reject">Reject()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_reject() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_reject_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Reject",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_service_name: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Connect">Connect()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_connect_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_connect_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_connect (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    const gchar *arg_service_name,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Connect",
+    g_variant_new ("(uuqyis)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_service_name),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_connect().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_connect().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_connect_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_service_name: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Connect">Connect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_connect() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_connect_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    const gchar *arg_service_name,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Connect",
+    g_variant_new ("(uuqyis)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_service_name),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect_sap:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ConnectSap">ConnectSap()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_connect_sap_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_connect_sap_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_connect_sap (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ConnectSap",
+    g_variant_new ("(uuqyiy)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_sap),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect_sap_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_connect_sap().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_connect_sap().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_connect_sap_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_connect_sap_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_miu: Argument to pass with the method invocation.
+ * @arg_rw: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ConnectSap">ConnectSap()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_connect_sap() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_connect_sap_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ConnectSap",
+    g_variant_new ("(uuqyiy)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_miu,
+                   arg_rw,
+                   arg_type,
+                   arg_sap),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Send">Send()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_send_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_send_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_send (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Send",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_send().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_send().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_send_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Send">Send()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_send() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_send_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GVariant *arg_data,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Send",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send_to:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.SendTo">SendTo()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_send_to_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_send_to_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_send_to (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guchar arg_sap,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SendTo",
+    g_variant_new ("(uuy@a(y))",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_sap,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send_to_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_send_to().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_send_to().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_send_to_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_send_to_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.SendTo">SendTo()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_send_to() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_send_to_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guchar arg_sap,
+    GVariant *arg_data,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SendTo",
+    g_variant_new ("(uuy@a(y))",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_sap,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_request_length: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Receive">Receive()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_receive_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_receive_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_receive (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Receive",
+    g_variant_new ("(uuu)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_request_length),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_receive().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_receive().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_receive_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_request_length: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Receive">Receive()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_receive() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_receive_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    gint *out_result,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Receive",
+    g_variant_new ("(uuu)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_request_length),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive_from:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_request_length: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ReceiveFrom">ReceiveFrom()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_receive_from_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_receive_from_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_receive_from (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ReceiveFrom",
+    g_variant_new ("(uuu)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_request_length),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive_from_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_sap: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_receive_from().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_receive_from().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_receive_from_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guchar *out_sap,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iy@a(y))",
+                 out_result,
+                 out_sap,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_receive_from_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @arg_request_length: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_sap: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ReceiveFrom">ReceiveFrom()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_receive_from() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_receive_from_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    gint *out_result,
+    guchar *out_sap,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ReceiveFrom",
+    g_variant_new ("(uuu)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_request_length),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iy@a(y))",
+                 out_result,
+                 out_sap,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_close:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Close">Close()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_close_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_close_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_close (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Close",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_close_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_close().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_close().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_close_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_close_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Close">Close()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_close() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_close_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Close",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_disconnect:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Disconnect">Disconnect()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_call_disconnect_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_call_disconnect_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_llcp_call_disconnect (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Disconnect",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_disconnect_finish:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_call_disconnect().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_call_disconnect().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_disconnect_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_call_disconnect_sync:
+ * @proxy: A #NetNfcGDbusLlcpProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_client_socket: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_client_socket: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Disconnect">Disconnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_call_disconnect() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_llcp_call_disconnect_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Disconnect",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_client_socket),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_client_socket);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_config:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Config">Config()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_config (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_listen:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Listen">Listen()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_listen (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_accept:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Accept">Accept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_accept (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_reject:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Reject">Reject()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_reject (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_connect:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_connect (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_connect_sap:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ConnectSap">ConnectSap()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_connect_sap (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_send:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_send (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_send_to:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.SendTo">SendTo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_send_to (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_receive:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Receive">Receive()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_receive (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   data));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_receive_from:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @sap: Parameter to return.
+ * @data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.ReceiveFrom">ReceiveFrom()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_receive_from (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guchar sap,
+    GVariant *data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iy@a(y))",
+                   result,
+                   sap,
+                   data));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_close:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Close">Close()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_close (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/**
+ * net_nfc_gdbus_llcp_complete_disconnect:
+ * @object: A #NetNfcGDbusLlcp.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @client_socket: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Llcp.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_llcp_complete_disconnect (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   client_socket));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusLlcpProxy:
+ *
+ * The #NetNfcGDbusLlcpProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusLlcpProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusLlcpProxy.
+ */
+
+struct _NetNfcGDbusLlcpProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_llcp_proxy_iface_init (NetNfcGDbusLlcpIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusLlcpProxy, net_nfc_gdbus_llcp_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusLlcpProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_LLCP, net_nfc_gdbus_llcp_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusLlcpProxy, net_nfc_gdbus_llcp_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_LLCP, net_nfc_gdbus_llcp_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_llcp_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusLlcpProxy *proxy = NET_NFC_GDBUS_LLCP_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_llcp_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_LLCP);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_LLCP);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusLlcpProxy *proxy = NET_NFC_GDBUS_LLCP_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_init (NetNfcGDbusLlcpProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_llcp_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_LLCP_PROXY, NetNfcGDbusLlcpProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_llcp_interface_info ());
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_class_init (NetNfcGDbusLlcpProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_llcp_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_llcp_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_llcp_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_llcp_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_llcp_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusLlcpProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_llcp_proxy_iface_init (NetNfcGDbusLlcpIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_llcp_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_LLCP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Llcp", NULL);
+}
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusLlcpProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusLlcp *
+net_nfc_gdbus_llcp_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_LLCP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusLlcpProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusLlcp *
+net_nfc_gdbus_llcp_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_LLCP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Llcp", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_LLCP (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_llcp_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_llcp_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_llcp_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_llcp_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_LLCP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Llcp", NULL);
+}
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_llcp_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_llcp_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusLlcpProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusLlcp *
+net_nfc_gdbus_llcp_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_LLCP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_llcp_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_llcp_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_llcp_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusLlcpProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusLlcp *
+net_nfc_gdbus_llcp_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_LLCP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Llcp", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_LLCP (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusLlcpSkeleton:
+ *
+ * The #NetNfcGDbusLlcpSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusLlcpSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusLlcpSkeleton.
+ */
+
+struct _NetNfcGDbusLlcpSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_llcp_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_LLCP);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_LLCP);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_llcp_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_llcp_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_llcp_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_llcp_skeleton_vtable =
+{
+  _net_nfc_gdbus_llcp_skeleton_handle_method_call,
+  _net_nfc_gdbus_llcp_skeleton_handle_get_property,
+  _net_nfc_gdbus_llcp_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_llcp_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_llcp_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_llcp_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_llcp_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_llcp_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_llcp_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_llcp_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_llcp_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_llcp_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Llcp", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_llcp_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_llcp_on_signal_error (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint arg_error)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(uui)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_error));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Llcp", "Error",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_llcp_on_signal_incoming (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_incoming_socket)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(uuu)",
+                   arg_handle,
+                   arg_client_socket,
+                   arg_incoming_socket));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Llcp", "Incoming",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_llcp_skeleton_iface_init (NetNfcGDbusLlcpIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusLlcpSkeleton, net_nfc_gdbus_llcp_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusLlcpSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_LLCP, net_nfc_gdbus_llcp_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusLlcpSkeleton, net_nfc_gdbus_llcp_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_LLCP, net_nfc_gdbus_llcp_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_llcp_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusLlcpSkeleton *skeleton = NET_NFC_GDBUS_LLCP_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_llcp_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_llcp_skeleton_init (NetNfcGDbusLlcpSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_llcp_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_LLCP_SKELETON, NetNfcGDbusLlcpSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_llcp_skeleton_class_init (NetNfcGDbusLlcpSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_llcp_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_llcp_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_llcp_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_llcp_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_llcp_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusLlcpSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_llcp_skeleton_iface_init (NetNfcGDbusLlcpIface *iface)
+{
+  iface->error = _net_nfc_gdbus_llcp_on_signal_error;
+  iface->incoming = _net_nfc_gdbus_llcp_on_signal_incoming;
+}
+
+/**
+ * net_nfc_gdbus_llcp_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Llcp.top_of_page">org.tizen.NetNfcService.Llcp</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusLlcpSkeleton): The skeleton object.
+ */
+NetNfcGDbusLlcp *
+net_nfc_gdbus_llcp_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_LLCP (g_object_new (NET_NFC_GDBUS_TYPE_LLCP_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.P2p
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusP2p
+ * @title: NetNfcGDbusP2p
+ * @short_description: Generated C code for the org.tizen.NetNfcService.P2p D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.P2p ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_method_info_send_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_method_info_send_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_method_info_send_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_p2p_method_info_send_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_method_info_send_IN_ARG_type,
+  &_net_nfc_gdbus_p2p_method_info_send_IN_ARG_data,
+  &_net_nfc_gdbus_p2p_method_info_send_IN_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_method_info_send_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_p2p_method_info_send_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_method_info_send_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_p2p_method_info_send =
+{
+  {
+    -1,
+    (gchar *) "Send",
+    (GDBusArgInfo **) &_net_nfc_gdbus_p2p_method_info_send_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_p2p_method_info_send_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-send",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_p2p_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_method_info_send,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_p2p_signal_info_detached =
+{
+  {
+    -1,
+    (gchar *) "Detached",
+    NULL,
+    NULL
+  },
+  "detached"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_signal_info_discovered_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_p2p_signal_info_discovered_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_signal_info_discovered_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_p2p_signal_info_discovered =
+{
+  {
+    -1,
+    (gchar *) "Discovered",
+    (GDBusArgInfo **) &_net_nfc_gdbus_p2p_signal_info_discovered_ARG_pointers,
+    NULL
+  },
+  "discovered"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_p2p_signal_info_received_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_p2p_signal_info_received_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_signal_info_received_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_p2p_signal_info_received =
+{
+  {
+    -1,
+    (gchar *) "Received",
+    (GDBusArgInfo **) &_net_nfc_gdbus_p2p_signal_info_received_ARG_pointers,
+    NULL
+  },
+  "received"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_p2p_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_p2p_signal_info_detached,
+  &_net_nfc_gdbus_p2p_signal_info_discovered,
+  &_net_nfc_gdbus_p2p_signal_info_received,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_p2p_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.P2p",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_p2p_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_p2p_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "p2p",
+};
+
+
+/**
+ * net_nfc_gdbus_p2p_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_p2p_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_p2p_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusP2p interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_p2p_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusP2p:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link>.
+ */
+
+/**
+ * NetNfcGDbusP2pIface:
+ * @parent_iface: The parent interface.
+ * @handle_send: Handler for the #NetNfcGDbusP2p::handle-send signal.
+ * @detached: Handler for the #NetNfcGDbusP2p::detached signal.
+ * @discovered: Handler for the #NetNfcGDbusP2p::discovered signal.
+ * @received: Handler for the #NetNfcGDbusP2p::received signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link>.
+ */
+
+typedef NetNfcGDbusP2pIface NetNfcGDbusP2pInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusP2p, net_nfc_gdbus_p2p, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_p2p_default_init (NetNfcGDbusP2pIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusP2p::handle-send:
+   * @object: A #NetNfcGDbusP2p.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   * @arg_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-P2p.Send">Send()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_p2p_complete_send() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-send",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusP2pIface, handle_send),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT, G_TYPE_VARIANT, G_TYPE_UINT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusP2p::detached:
+   * @object: A #NetNfcGDbusP2p.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Detached">"Detached"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("detached",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusP2pIface, detached),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    0);
+
+  /**
+   * NetNfcGDbusP2p::discovered:
+   * @object: A #NetNfcGDbusP2p.
+   * @arg_handle: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Discovered">"Discovered"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("discovered",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusP2pIface, discovered),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusP2p::received:
+   * @object: A #NetNfcGDbusP2p.
+   * @arg_data: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Received">"Received"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("received",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusP2pIface, received),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_VARIANT);
+
+}
+
+/**
+ * net_nfc_gdbus_p2p_emit_detached:
+ * @object: A #NetNfcGDbusP2p.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Detached">"Detached"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_p2p_emit_detached (
+    NetNfcGDbusP2p *object)
+{
+  g_signal_emit_by_name (object, "detached");
+}
+
+/**
+ * net_nfc_gdbus_p2p_emit_discovered:
+ * @object: A #NetNfcGDbusP2p.
+ * @arg_handle: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Discovered">"Discovered"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_p2p_emit_discovered (
+    NetNfcGDbusP2p *object,
+    guint arg_handle)
+{
+  g_signal_emit_by_name (object, "discovered", arg_handle);
+}
+
+/**
+ * net_nfc_gdbus_p2p_emit_received:
+ * @object: A #NetNfcGDbusP2p.
+ * @arg_data: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-P2p.Received">"Received"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_p2p_emit_received (
+    NetNfcGDbusP2p *object,
+    GVariant *arg_data)
+{
+  g_signal_emit_by_name (object, "received", arg_data);
+}
+
+/**
+ * net_nfc_gdbus_p2p_call_send:
+ * @proxy: A #NetNfcGDbusP2pProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-P2p.Send">Send()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_p2p_call_send_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_p2p_call_send_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_p2p_call_send (
+    NetNfcGDbusP2p *proxy,
+    gint arg_type,
+    GVariant *arg_data,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Send",
+    g_variant_new ("(i@a(y)u)",
+                   arg_type,
+                   arg_data,
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_p2p_call_send_finish:
+ * @proxy: A #NetNfcGDbusP2pProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_p2p_call_send().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_p2p_call_send().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_p2p_call_send_finish (
+    NetNfcGDbusP2p *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_p2p_call_send_sync:
+ * @proxy: A #NetNfcGDbusP2pProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-P2p.Send">Send()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_p2p_call_send() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_p2p_call_send_sync (
+    NetNfcGDbusP2p *proxy,
+    gint arg_type,
+    GVariant *arg_data,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Send",
+    g_variant_new ("(i@a(y)u)",
+                   arg_type,
+                   arg_data,
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_p2p_complete_send:
+ * @object: A #NetNfcGDbusP2p.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-P2p.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_p2p_complete_send (
+    NetNfcGDbusP2p *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusP2pProxy:
+ *
+ * The #NetNfcGDbusP2pProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusP2pProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusP2pProxy.
+ */
+
+struct _NetNfcGDbusP2pProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_p2p_proxy_iface_init (NetNfcGDbusP2pIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusP2pProxy, net_nfc_gdbus_p2p_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusP2pProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_P2P, net_nfc_gdbus_p2p_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusP2pProxy, net_nfc_gdbus_p2p_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_P2P, net_nfc_gdbus_p2p_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_p2p_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusP2pProxy *proxy = NET_NFC_GDBUS_P2P_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_p2p_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_P2P);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_P2P);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusP2pProxy *proxy = NET_NFC_GDBUS_P2P_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_init (NetNfcGDbusP2pProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_p2p_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_P2P_PROXY, NetNfcGDbusP2pProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_p2p_interface_info ());
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_class_init (NetNfcGDbusP2pProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_p2p_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_p2p_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_p2p_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_p2p_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_p2p_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusP2pProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_p2p_proxy_iface_init (NetNfcGDbusP2pIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_p2p_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_p2p_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_p2p_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_P2P_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.P2p", NULL);
+}
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_p2p_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_p2p_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusP2pProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusP2p *
+net_nfc_gdbus_p2p_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_P2P (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_p2p_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusP2pProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusP2p *
+net_nfc_gdbus_p2p_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_P2P_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.P2p", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_P2P (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_p2p_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_p2p_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_p2p_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_p2p_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_P2P_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.P2p", NULL);
+}
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_p2p_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_p2p_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusP2pProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusP2p *
+net_nfc_gdbus_p2p_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_P2P (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_p2p_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_p2p_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_p2p_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusP2pProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusP2p *
+net_nfc_gdbus_p2p_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_P2P_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.P2p", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_P2P (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusP2pSkeleton:
+ *
+ * The #NetNfcGDbusP2pSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusP2pSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusP2pSkeleton.
+ */
+
+struct _NetNfcGDbusP2pSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_p2p_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_P2P);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_P2P);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_p2p_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_p2p_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_p2p_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_p2p_skeleton_vtable =
+{
+  _net_nfc_gdbus_p2p_skeleton_handle_method_call,
+  _net_nfc_gdbus_p2p_skeleton_handle_get_property,
+  _net_nfc_gdbus_p2p_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_p2p_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_p2p_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_p2p_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_p2p_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_p2p_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_p2p_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_p2p_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_p2p_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_p2p_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.P2p", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_p2p_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_p2p_on_signal_detached (
+    NetNfcGDbusP2p *object)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("()"));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.P2p", "Detached",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_p2p_on_signal_discovered (
+    NetNfcGDbusP2p *object,
+    guint arg_handle)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(u)",
+                   arg_handle));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.P2p", "Discovered",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_p2p_on_signal_received (
+    NetNfcGDbusP2p *object,
+    GVariant *arg_data)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(@a(y))",
+                   arg_data));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.P2p", "Received",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_p2p_skeleton_iface_init (NetNfcGDbusP2pIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusP2pSkeleton, net_nfc_gdbus_p2p_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusP2pSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_P2P, net_nfc_gdbus_p2p_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusP2pSkeleton, net_nfc_gdbus_p2p_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_P2P, net_nfc_gdbus_p2p_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_p2p_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusP2pSkeleton *skeleton = NET_NFC_GDBUS_P2P_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_p2p_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_p2p_skeleton_init (NetNfcGDbusP2pSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_p2p_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_P2P_SKELETON, NetNfcGDbusP2pSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_p2p_skeleton_class_init (NetNfcGDbusP2pSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_p2p_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_p2p_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_p2p_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_p2p_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_p2p_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusP2pSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_p2p_skeleton_iface_init (NetNfcGDbusP2pIface *iface)
+{
+  iface->detached = _net_nfc_gdbus_p2p_on_signal_detached;
+  iface->discovered = _net_nfc_gdbus_p2p_on_signal_discovered;
+  iface->received = _net_nfc_gdbus_p2p_on_signal_received;
+}
+
+/**
+ * net_nfc_gdbus_p2p_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-P2p.top_of_page">org.tizen.NetNfcService.P2p</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusP2pSkeleton): The skeleton object.
+ */
+NetNfcGDbusP2p *
+net_nfc_gdbus_p2p_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_P2P (g_object_new (NET_NFC_GDBUS_TYPE_P2P_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Popup
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusPopup
+ * @title: NetNfcGDbusPopup
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Popup D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Popup ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_popup_method_info_set_IN_ARG_state =
+{
+  {
+    -1,
+    (gchar *) "state",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_popup_method_info_set_IN_ARG_focus_state =
+{
+  {
+    -1,
+    (gchar *) "focus_state",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_popup_method_info_set_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_popup_method_info_set_IN_ARG_state,
+  &_net_nfc_gdbus_popup_method_info_set_IN_ARG_focus_state,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_popup_method_info_set_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_popup_method_info_set_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_popup_method_info_set_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_popup_method_info_set =
+{
+  {
+    -1,
+    (gchar *) "Set",
+    (GDBusArgInfo **) &_net_nfc_gdbus_popup_method_info_set_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_popup_method_info_set_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_popup_method_info_get_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_popup_method_info_get_OUT_ARG_state =
+{
+  {
+    -1,
+    (gchar *) "state",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_popup_method_info_get_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_popup_method_info_get_OUT_ARG_result,
+  &_net_nfc_gdbus_popup_method_info_get_OUT_ARG_state,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_popup_method_info_get =
+{
+  {
+    -1,
+    (gchar *) "Get",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_popup_method_info_get_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_popup_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_popup_method_info_set,
+  &_net_nfc_gdbus_popup_method_info_get,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_popup_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Popup",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_popup_method_info_pointers,
+    NULL,
+    NULL,
+    NULL
+  },
+  "popup",
+};
+
+
+/**
+ * net_nfc_gdbus_popup_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_popup_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_popup_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusPopup interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_popup_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusPopup:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link>.
+ */
+
+/**
+ * NetNfcGDbusPopupIface:
+ * @parent_iface: The parent interface.
+ * @handle_get: Handler for the #NetNfcGDbusPopup::handle-get signal.
+ * @handle_set: Handler for the #NetNfcGDbusPopup::handle-set signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link>.
+ */
+
+typedef NetNfcGDbusPopupIface NetNfcGDbusPopupInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusPopup, net_nfc_gdbus_popup, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_popup_default_init (NetNfcGDbusPopupIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusPopup::handle-set:
+   * @object: A #NetNfcGDbusPopup.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_state: Argument passed by remote caller.
+   * @arg_focus_state: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Set">Set()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_popup_complete_set() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusPopupIface, handle_set),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusPopup::handle-get:
+   * @object: A #NetNfcGDbusPopup.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Get">Get()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_popup_complete_get() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusPopupIface, handle_get),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+}
+
+/**
+ * net_nfc_gdbus_popup_call_set:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @arg_state: Argument to pass with the method invocation.
+ * @arg_focus_state: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Set">Set()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_popup_call_set_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_popup_call_set_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_popup_call_set (
+    NetNfcGDbusPopup *proxy,
+    gint arg_state,
+    gint arg_focus_state,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Set",
+    g_variant_new ("(ii)",
+                   arg_state,
+                   arg_focus_state),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_popup_call_set_finish:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_popup_call_set().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_popup_call_set().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_popup_call_set_finish (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_call_set_sync:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @arg_state: Argument to pass with the method invocation.
+ * @arg_focus_state: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Set">Set()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_popup_call_set() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_popup_call_set_sync (
+    NetNfcGDbusPopup *proxy,
+    gint arg_state,
+    gint arg_focus_state,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Set",
+    g_variant_new ("(ii)",
+                   arg_state,
+                   arg_focus_state),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_call_get:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Get">Get()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_popup_call_get_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_popup_call_get_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_popup_call_get (
+    NetNfcGDbusPopup *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Get",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_popup_call_get_finish:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_state: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_popup_call_get().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_popup_call_get().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_popup_call_get_finish (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    gint *out_state,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_state);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_call_get_sync:
+ * @proxy: A #NetNfcGDbusPopupProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_state: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Get">Get()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_popup_call_get() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_popup_call_get_sync (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    gint *out_state,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Get",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_state);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_complete_set:
+ * @object: A #NetNfcGDbusPopup.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_popup_complete_set (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_popup_complete_get:
+ * @object: A #NetNfcGDbusPopup.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @state: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Popup.Get">Get()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_popup_complete_get (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint state)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ii)",
+                   result,
+                   state));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusPopupProxy:
+ *
+ * The #NetNfcGDbusPopupProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusPopupProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusPopupProxy.
+ */
+
+struct _NetNfcGDbusPopupProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_popup_proxy_iface_init (NetNfcGDbusPopupIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusPopupProxy, net_nfc_gdbus_popup_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusPopupProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_POPUP, net_nfc_gdbus_popup_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusPopupProxy, net_nfc_gdbus_popup_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_POPUP, net_nfc_gdbus_popup_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_popup_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusPopupProxy *proxy = NET_NFC_GDBUS_POPUP_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_popup_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_popup_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_popup_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_popup_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_POPUP);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_POPUP);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_popup_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusPopupProxy *proxy = NET_NFC_GDBUS_POPUP_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_popup_proxy_init (NetNfcGDbusPopupProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_popup_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_POPUP_PROXY, NetNfcGDbusPopupProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_popup_interface_info ());
+}
+
+static void
+net_nfc_gdbus_popup_proxy_class_init (NetNfcGDbusPopupProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_popup_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_popup_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_popup_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_popup_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_popup_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusPopupProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_popup_proxy_iface_init (NetNfcGDbusPopupIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_popup_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_popup_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_popup_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_popup_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_POPUP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Popup", NULL);
+}
+
+/**
+ * net_nfc_gdbus_popup_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_popup_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_popup_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusPopupProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusPopup *
+net_nfc_gdbus_popup_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_POPUP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_popup_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusPopupProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusPopup *
+net_nfc_gdbus_popup_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_POPUP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Popup", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_POPUP (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_popup_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_popup_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_popup_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_popup_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_popup_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_POPUP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Popup", NULL);
+}
+
+/**
+ * net_nfc_gdbus_popup_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_popup_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_popup_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusPopupProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusPopup *
+net_nfc_gdbus_popup_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_POPUP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_popup_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_popup_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_popup_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusPopupProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusPopup *
+net_nfc_gdbus_popup_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_POPUP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Popup", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_POPUP (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusPopupSkeleton:
+ *
+ * The #NetNfcGDbusPopupSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusPopupSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusPopupSkeleton.
+ */
+
+struct _NetNfcGDbusPopupSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_popup_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusPopupSkeleton *skeleton = NET_NFC_GDBUS_POPUP_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_POPUP);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_POPUP);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_popup_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusPopupSkeleton *skeleton = NET_NFC_GDBUS_POPUP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_popup_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusPopupSkeleton *skeleton = NET_NFC_GDBUS_POPUP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_popup_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_popup_skeleton_vtable =
+{
+  _net_nfc_gdbus_popup_skeleton_handle_method_call,
+  _net_nfc_gdbus_popup_skeleton_handle_get_property,
+  _net_nfc_gdbus_popup_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_popup_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_popup_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_popup_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_popup_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_popup_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusPopupSkeleton *skeleton = NET_NFC_GDBUS_POPUP_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_popup_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_popup_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_popup_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_popup_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Popup", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_popup_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void net_nfc_gdbus_popup_skeleton_iface_init (NetNfcGDbusPopupIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusPopupSkeleton, net_nfc_gdbus_popup_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusPopupSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_POPUP, net_nfc_gdbus_popup_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusPopupSkeleton, net_nfc_gdbus_popup_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_POPUP, net_nfc_gdbus_popup_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_popup_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusPopupSkeleton *skeleton = NET_NFC_GDBUS_POPUP_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_popup_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_popup_skeleton_init (NetNfcGDbusPopupSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_popup_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_POPUP_SKELETON, NetNfcGDbusPopupSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_popup_skeleton_class_init (NetNfcGDbusPopupSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_popup_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_popup_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_popup_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_popup_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_popup_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusPopupSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_popup_skeleton_iface_init (NetNfcGDbusPopupIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_popup_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Popup.top_of_page">org.tizen.NetNfcService.Popup</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusPopupSkeleton): The skeleton object.
+ */
+NetNfcGDbusPopup *
+net_nfc_gdbus_popup_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_POPUP (g_object_new (NET_NFC_GDBUS_TYPE_POPUP_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.SecureElement
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusSecureElement
+ * @title: NetNfcGDbusSecureElement
+ * @short_description: Generated C code for the org.tizen.NetNfcService.SecureElement D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.SecureElement ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_IN_ARG_type,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_set =
+{
+  {
+    -1,
+    (gchar *) "Set",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_type,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get =
+{
+  {
+    -1,
+    (gchar *) "Get",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_card_emulation_IN_ARG_mode =
+{
+  {
+    -1,
+    (gchar *) "mode",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_card_emulation_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_card_emulation_IN_ARG_mode,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_card_emulation_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_card_emulation_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_card_emulation_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_set_card_emulation =
+{
+  {
+    -1,
+    (gchar *) "SetCardEmulation",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_card_emulation_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_card_emulation_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-card-emulation",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_type,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_card_emulation =
+{
+  {
+    -1,
+    (gchar *) "GetCardEmulation",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_card_emulation_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-card-emulation",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_open_secure_element_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_open_secure_element_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_open_secure_element_IN_ARG_type,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_open_secure_element =
+{
+  {
+    -1,
+    (gchar *) "OpenSecureElement",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_open_secure_element_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_open_secure_element_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-open-secure-element",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_close_secure_element_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_close_secure_element_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_close_secure_element_IN_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_close_secure_element_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_close_secure_element_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_close_secure_element_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_close_secure_element =
+{
+  {
+    -1,
+    (gchar *) "CloseSecureElement",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_close_secure_element_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_close_secure_element_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-close-secure-element",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_atr_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_atr_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_atr_IN_ARG_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_atr =
+{
+  {
+    -1,
+    (gchar *) "atr",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_atr,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_atr =
+{
+  {
+    -1,
+    (gchar *) "GetAtr",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_atr_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_atr_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-atr",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_handle,
+  &_net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_response =
+{
+  {
+    -1,
+    (gchar *) "response",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_response,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_send_apdu =
+{
+  {
+    -1,
+    (gchar *) "SendAPDU",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_send_apdu_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_send_apdu_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-send-apdu",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_IN_ARG_mode =
+{
+  {
+    -1,
+    (gchar *) "mode",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_IN_ARG_mode,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch =
+{
+  {
+    -1,
+    (gchar *) "SetTransactionFgDispatch",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-transaction-fg-dispatch",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_switch_on =
+{
+  {
+    -1,
+    (gchar *) "switch_on",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_switch_off =
+{
+  {
+    -1,
+    (gchar *) "switch_off",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_battery_off =
+{
+  {
+    -1,
+    (gchar *) "battery_off",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_switch_on,
+  &_net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_switch_off,
+  &_net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_battery_off,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_default_route_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_default_route_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_default_route_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_set_default_route =
+{
+  {
+    -1,
+    (gchar *) "SetDefaultRoute",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_default_route_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_default_route_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-default-route",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_preferred_handler_IN_ARG_state =
+{
+  {
+    -1,
+    (gchar *) "state",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_preferred_handler_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_preferred_handler_IN_ARG_state,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_set_preferred_handler_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_set_preferred_handler_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set_preferred_handler_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_set_preferred_handler =
+{
+  {
+    -1,
+    (gchar *) "SetPreferredHandler",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_preferred_handler_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_set_preferred_handler_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-preferred-handler",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_check_transaction_permission_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_check_transaction_permission_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_check_transaction_permission_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_check_transaction_permission_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_check_transaction_permission_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_check_transaction_permission_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_check_transaction_permission =
+{
+  {
+    -1,
+    (gchar *) "CheckTransactionPermission",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_check_transaction_permission_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_check_transaction_permission_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-check-transaction-permission",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_activated =
+{
+  {
+    -1,
+    (gchar *) "activated",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_activated,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler =
+{
+  {
+    -1,
+    (gchar *) "IsActivatedAidHandler",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-is-activated-aid-handler",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_category,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_activated =
+{
+  {
+    -1,
+    (gchar *) "activated",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_activated,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_is_activated_category_handler =
+{
+  {
+    -1,
+    (gchar *) "IsActivatedCategoryHandler",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-is-activated-category-handler",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_category,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_aids =
+{
+  {
+    -1,
+    (gchar *) "aids",
+    (gchar *) "a(sb)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_aids,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_registered_aids =
+{
+  {
+    -1,
+    (gchar *) "GetRegisteredAids",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_registered_aids_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-registered-aids",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_category,
+  &_net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_register_aid_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_register_aid_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_register_aid_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_register_aid =
+{
+  {
+    -1,
+    (gchar *) "RegisterAid",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_register_aid_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_register_aid_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-register-aid",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_category,
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aid_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_unregister_aid_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aid_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_unregister_aid =
+{
+  {
+    -1,
+    (gchar *) "UnregisterAid",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_unregister_aid_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_unregister_aid_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-unregister-aid",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_type,
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_category,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_unregister_aids_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_unregister_aids_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aids_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_unregister_aids =
+{
+  {
+    -1,
+    (gchar *) "UnregisterAids",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_unregister_aids_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_unregister_aids_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-unregister-aids",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_package =
+{
+  {
+    -1,
+    (gchar *) "package",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_se_type =
+{
+  {
+    -1,
+    (gchar *) "se_type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_unlock =
+{
+  {
+    -1,
+    (gchar *) "unlock",
+    (gchar *) "b",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_power =
+{
+  {
+    -1,
+    (gchar *) "power",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_package,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_aid,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_se_type,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_category,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_unlock,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_power,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_add_route_aid_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_add_route_aid =
+{
+  {
+    -1,
+    (gchar *) "AddRouteAid",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_add_route_aid_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_add_route_aid_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-add-route-aid",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_package =
+{
+  {
+    -1,
+    (gchar *) "package",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_package,
+  &_net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_remove_route_aid_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_remove_route_aid_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_remove_route_aid_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_remove_route_aid =
+{
+  {
+    -1,
+    (gchar *) "RemoveRouteAid",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_remove_route_aid_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_remove_route_aid_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-remove-route-aid",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_remove_package_aids_IN_ARG_package =
+{
+  {
+    -1,
+    (gchar *) "package",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_remove_package_aids_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_remove_package_aids_IN_ARG_package,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_remove_package_aids_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_remove_package_aids_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_remove_package_aids_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_remove_package_aids =
+{
+  {
+    -1,
+    (gchar *) "RemovePackageAids",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_remove_package_aids_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_remove_package_aids_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-remove-package-aids",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_handlers_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_registered_handlers_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers_IN_ARG_category,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_packages =
+{
+  {
+    -1,
+    (gchar *) "packages",
+    (gchar *) "a(is)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_packages,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_registered_handlers =
+{
+  {
+    -1,
+    (gchar *) "GetRegisteredHandlers",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-registered-handlers",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_IN_ARG_category,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_used =
+{
+  {
+    -1,
+    (gchar *) "used",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_maximum =
+{
+  {
+    -1,
+    (gchar *) "maximum",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_used,
+  &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_maximum,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_handler_storage_info =
+{
+  {
+    -1,
+    (gchar *) "GetHandlerStorageInfo",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-handler-storage-info",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_package =
+{
+  {
+    -1,
+    (gchar *) "package",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_category =
+{
+  {
+    -1,
+    (gchar *) "category",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_package,
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_category,
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_aid,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_packages =
+{
+  {
+    -1,
+    (gchar *) "packages",
+    (gchar *) "a(s)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_result,
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_packages,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_secure_element_method_info_get_conflict_handlers =
+{
+  {
+    -1,
+    (gchar *) "GetConflictHandlers",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-conflict-handlers",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_secure_element_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_method_info_set,
+  &_net_nfc_gdbus_secure_element_method_info_get,
+  &_net_nfc_gdbus_secure_element_method_info_set_card_emulation,
+  &_net_nfc_gdbus_secure_element_method_info_get_card_emulation,
+  &_net_nfc_gdbus_secure_element_method_info_open_secure_element,
+  &_net_nfc_gdbus_secure_element_method_info_close_secure_element,
+  &_net_nfc_gdbus_secure_element_method_info_get_atr,
+  &_net_nfc_gdbus_secure_element_method_info_send_apdu,
+  &_net_nfc_gdbus_secure_element_method_info_set_transaction_fg_dispatch,
+  &_net_nfc_gdbus_secure_element_method_info_set_default_route,
+  &_net_nfc_gdbus_secure_element_method_info_set_preferred_handler,
+  &_net_nfc_gdbus_secure_element_method_info_check_transaction_permission,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_aid_handler,
+  &_net_nfc_gdbus_secure_element_method_info_is_activated_category_handler,
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_aids,
+  &_net_nfc_gdbus_secure_element_method_info_register_aid,
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aid,
+  &_net_nfc_gdbus_secure_element_method_info_unregister_aids,
+  &_net_nfc_gdbus_secure_element_method_info_add_route_aid,
+  &_net_nfc_gdbus_secure_element_method_info_remove_route_aid,
+  &_net_nfc_gdbus_secure_element_method_info_remove_package_aids,
+  &_net_nfc_gdbus_secure_element_method_info_get_registered_handlers,
+  &_net_nfc_gdbus_secure_element_method_info_get_handler_storage_info,
+  &_net_nfc_gdbus_secure_element_method_info_get_conflict_handlers,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_se_type =
+{
+  {
+    -1,
+    (gchar *) "se_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_handle,
+  &_net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_se_type,
+  &_net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_secure_element_signal_info_ese_detected =
+{
+  {
+    -1,
+    (gchar *) "EseDetected",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_signal_info_ese_detected_ARG_pointers,
+    NULL
+  },
+  "ese-detected"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_se_type_changed_ARG_se_type =
+{
+  {
+    -1,
+    (gchar *) "se_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_signal_info_se_type_changed_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_signal_info_se_type_changed_ARG_se_type,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_secure_element_signal_info_se_type_changed =
+{
+  {
+    -1,
+    (gchar *) "SeTypeChanged",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_signal_info_se_type_changed_ARG_pointers,
+    NULL
+  },
+  "se-type-changed"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed_ARG_mode =
+{
+  {
+    -1,
+    (gchar *) "mode",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed_ARG_mode,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed =
+{
+  {
+    -1,
+    (gchar *) "CardEmulationModeChanged",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed_ARG_pointers,
+    NULL
+  },
+  "card-emulation-mode-changed"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_se_type =
+{
+  {
+    -1,
+    (gchar *) "se_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_aid =
+{
+  {
+    -1,
+    (gchar *) "aid",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_param =
+{
+  {
+    -1,
+    (gchar *) "param",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_fg_dispatch =
+{
+  {
+    -1,
+    (gchar *) "fg_dispatch",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_focus_pgid =
+{
+  {
+    -1,
+    (gchar *) "focus_pgid",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_se_type,
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_aid,
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_param,
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_fg_dispatch,
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_focus_pgid,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_secure_element_signal_info_transaction_event =
+{
+  {
+    -1,
+    (gchar *) "TransactionEvent",
+    (GDBusArgInfo **) &_net_nfc_gdbus_secure_element_signal_info_transaction_event_ARG_pointers,
+    NULL
+  },
+  "transaction-event"
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_secure_element_signal_info_rf_detected =
+{
+  {
+    -1,
+    (gchar *) "RfDetected",
+    NULL,
+    NULL
+  },
+  "rf-detected"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_secure_element_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_secure_element_signal_info_ese_detected,
+  &_net_nfc_gdbus_secure_element_signal_info_se_type_changed,
+  &_net_nfc_gdbus_secure_element_signal_info_card_emulation_mode_changed,
+  &_net_nfc_gdbus_secure_element_signal_info_transaction_event,
+  &_net_nfc_gdbus_secure_element_signal_info_rf_detected,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_secure_element_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.SecureElement",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_secure_element_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_secure_element_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "secure-element",
+};
+
+
+/**
+ * net_nfc_gdbus_secure_element_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_secure_element_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusSecureElement interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_secure_element_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusSecureElement:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link>.
+ */
+
+/**
+ * NetNfcGDbusSecureElementIface:
+ * @parent_iface: The parent interface.
+ * @handle_add_route_aid: Handler for the #NetNfcGDbusSecureElement::handle-add-route-aid signal.
+ * @handle_check_transaction_permission: Handler for the #NetNfcGDbusSecureElement::handle-check-transaction-permission signal.
+ * @handle_close_secure_element: Handler for the #NetNfcGDbusSecureElement::handle-close-secure-element signal.
+ * @handle_get: Handler for the #NetNfcGDbusSecureElement::handle-get signal.
+ * @handle_get_atr: Handler for the #NetNfcGDbusSecureElement::handle-get-atr signal.
+ * @handle_get_card_emulation: Handler for the #NetNfcGDbusSecureElement::handle-get-card-emulation signal.
+ * @handle_get_conflict_handlers: Handler for the #NetNfcGDbusSecureElement::handle-get-conflict-handlers signal.
+ * @handle_get_handler_storage_info: Handler for the #NetNfcGDbusSecureElement::handle-get-handler-storage-info signal.
+ * @handle_get_registered_aids: Handler for the #NetNfcGDbusSecureElement::handle-get-registered-aids signal.
+ * @handle_get_registered_handlers: Handler for the #NetNfcGDbusSecureElement::handle-get-registered-handlers signal.
+ * @handle_is_activated_aid_handler: Handler for the #NetNfcGDbusSecureElement::handle-is-activated-aid-handler signal.
+ * @handle_is_activated_category_handler: Handler for the #NetNfcGDbusSecureElement::handle-is-activated-category-handler signal.
+ * @handle_open_secure_element: Handler for the #NetNfcGDbusSecureElement::handle-open-secure-element signal.
+ * @handle_register_aid: Handler for the #NetNfcGDbusSecureElement::handle-register-aid signal.
+ * @handle_remove_package_aids: Handler for the #NetNfcGDbusSecureElement::handle-remove-package-aids signal.
+ * @handle_remove_route_aid: Handler for the #NetNfcGDbusSecureElement::handle-remove-route-aid signal.
+ * @handle_send_apdu: Handler for the #NetNfcGDbusSecureElement::handle-send-apdu signal.
+ * @handle_set: Handler for the #NetNfcGDbusSecureElement::handle-set signal.
+ * @handle_set_card_emulation: Handler for the #NetNfcGDbusSecureElement::handle-set-card-emulation signal.
+ * @handle_set_default_route: Handler for the #NetNfcGDbusSecureElement::handle-set-default-route signal.
+ * @handle_set_preferred_handler: Handler for the #NetNfcGDbusSecureElement::handle-set-preferred-handler signal.
+ * @handle_set_transaction_fg_dispatch: Handler for the #NetNfcGDbusSecureElement::handle-set-transaction-fg-dispatch signal.
+ * @handle_unregister_aid: Handler for the #NetNfcGDbusSecureElement::handle-unregister-aid signal.
+ * @handle_unregister_aids: Handler for the #NetNfcGDbusSecureElement::handle-unregister-aids signal.
+ * @card_emulation_mode_changed: Handler for the #NetNfcGDbusSecureElement::card-emulation-mode-changed signal.
+ * @ese_detected: Handler for the #NetNfcGDbusSecureElement::ese-detected signal.
+ * @rf_detected: Handler for the #NetNfcGDbusSecureElement::rf-detected signal.
+ * @se_type_changed: Handler for the #NetNfcGDbusSecureElement::se-type-changed signal.
+ * @transaction_event: Handler for the #NetNfcGDbusSecureElement::transaction-event signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link>.
+ */
+
+typedef NetNfcGDbusSecureElementIface NetNfcGDbusSecureElementInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusSecureElement, net_nfc_gdbus_secure_element, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_secure_element_default_init (NetNfcGDbusSecureElementIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusSecureElement::handle-set:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Set">Set()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_set() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_set),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Get">Get()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-set-card-emulation:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_mode: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetCardEmulation">SetCardEmulation()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_set_card_emulation() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-card-emulation",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_set_card_emulation),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-card-emulation:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetCardEmulation">GetCardEmulation()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_card_emulation() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-card-emulation",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_card_emulation),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-open-secure-element:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.OpenSecureElement">OpenSecureElement()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_open_secure_element() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-open-secure-element",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_open_secure_element),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-close-secure-element:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CloseSecureElement">CloseSecureElement()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_close_secure_element() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-close-secure-element",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_close_secure_element),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-atr:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetAtr">GetAtr()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_atr() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-atr",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_atr),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-send-apdu:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SendAPDU">SendAPDU()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_send_apdu() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-send-apdu",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_send_apdu),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-set-transaction-fg-dispatch:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_mode: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetTransactionFgDispatch">SetTransactionFgDispatch()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_set_transaction_fg_dispatch() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-transaction-fg-dispatch",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_set_transaction_fg_dispatch),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-set-default-route:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_switch_on: Argument passed by remote caller.
+   * @arg_switch_off: Argument passed by remote caller.
+   * @arg_battery_off: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetDefaultRoute">SetDefaultRoute()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_set_default_route() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-default-route",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_set_default_route),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-set-preferred-handler:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_state: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetPreferredHandler">SetPreferredHandler()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_set_preferred_handler() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-preferred-handler",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_set_preferred_handler),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-check-transaction-permission:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CheckTransactionPermission">CheckTransactionPermission()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_check_transaction_permission() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-check-transaction-permission",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_check_transaction_permission),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-is-activated-aid-handler:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedAidHandler">IsActivatedAidHandler()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_is_activated_aid_handler() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-is-activated-aid-handler",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_is_activated_aid_handler),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-is-activated-category-handler:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedCategoryHandler">IsActivatedCategoryHandler()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_is_activated_category_handler() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-is-activated-category-handler",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_is_activated_category_handler),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-registered-aids:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredAids">GetRegisteredAids()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_registered_aids() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-registered-aids",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_registered_aids),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-register-aid:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RegisterAid">RegisterAid()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_register_aid() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-register-aid",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_register_aid),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-unregister-aid:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAid">UnregisterAid()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_unregister_aid() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-unregister-aid",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_unregister_aid),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-unregister-aids:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAids">UnregisterAids()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_unregister_aids() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-unregister-aids",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_unregister_aids),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-add-route-aid:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_package: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   * @arg_se_type: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   * @arg_unlock: Argument passed by remote caller.
+   * @arg_power: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.AddRouteAid">AddRouteAid()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_add_route_aid() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-add-route-aid",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_add_route_aid),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    7,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-remove-route-aid:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_package: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemoveRouteAid">RemoveRouteAid()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_remove_route_aid() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-remove-route-aid",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_remove_route_aid),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-remove-package-aids:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_package: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemovePackageAids">RemovePackageAids()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_remove_package_aids() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-remove-package-aids",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_remove_package_aids),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-registered-handlers:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_category: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredHandlers">GetRegisteredHandlers()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_registered_handlers() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-registered-handlers",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_registered_handlers),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-handler-storage-info:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_category: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetHandlerStorageInfo">GetHandlerStorageInfo()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_handler_storage_info() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-handler-storage-info",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_handler_storage_info),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSecureElement::handle-get-conflict-handlers:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_package: Argument passed by remote caller.
+   * @arg_category: Argument passed by remote caller.
+   * @arg_aid: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetConflictHandlers">GetConflictHandlers()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_secure_element_complete_get_conflict_handlers() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-conflict-handlers",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, handle_get_conflict_handlers),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusSecureElement::ese-detected:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @arg_handle: Argument.
+   * @arg_se_type: Argument.
+   * @arg_data: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.EseDetected">"EseDetected"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("ese-detected",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, ese_detected),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    3, G_TYPE_UINT, G_TYPE_INT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusSecureElement::se-type-changed:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @arg_se_type: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.SeTypeChanged">"SeTypeChanged"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("se-type-changed",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, se_type_changed),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::card-emulation-mode-changed:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @arg_mode: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.CardEmulationModeChanged">"CardEmulationModeChanged"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("card-emulation-mode-changed",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, card_emulation_mode_changed),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::transaction-event:
+   * @object: A #NetNfcGDbusSecureElement.
+   * @arg_se_type: Argument.
+   * @arg_aid: Argument.
+   * @arg_param: Argument.
+   * @arg_fg_dispatch: Argument.
+   * @arg_focus_pgid: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.TransactionEvent">"TransactionEvent"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("transaction-event",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, transaction_event),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    5, G_TYPE_INT, G_TYPE_VARIANT, G_TYPE_VARIANT, G_TYPE_INT, G_TYPE_INT);
+
+  /**
+   * NetNfcGDbusSecureElement::rf-detected:
+   * @object: A #NetNfcGDbusSecureElement.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.RfDetected">"RfDetected"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("rf-detected",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSecureElementIface, rf_detected),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    0);
+
+}
+
+/**
+ * net_nfc_gdbus_secure_element_emit_ese_detected:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_se_type: Argument to pass with the signal.
+ * @arg_data: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.EseDetected">"EseDetected"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_secure_element_emit_ese_detected (
+    NetNfcGDbusSecureElement *object,
+    guint arg_handle,
+    gint arg_se_type,
+    GVariant *arg_data)
+{
+  g_signal_emit_by_name (object, "ese-detected", arg_handle, arg_se_type, arg_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_emit_se_type_changed:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @arg_se_type: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.SeTypeChanged">"SeTypeChanged"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_secure_element_emit_se_type_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type)
+{
+  g_signal_emit_by_name (object, "se-type-changed", arg_se_type);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_emit_card_emulation_mode_changed:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @arg_mode: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.CardEmulationModeChanged">"CardEmulationModeChanged"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_secure_element_emit_card_emulation_mode_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_mode)
+{
+  g_signal_emit_by_name (object, "card-emulation-mode-changed", arg_mode);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_emit_transaction_event:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @arg_se_type: Argument to pass with the signal.
+ * @arg_aid: Argument to pass with the signal.
+ * @arg_param: Argument to pass with the signal.
+ * @arg_fg_dispatch: Argument to pass with the signal.
+ * @arg_focus_pgid: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.TransactionEvent">"TransactionEvent"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_secure_element_emit_transaction_event (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type,
+    GVariant *arg_aid,
+    GVariant *arg_param,
+    gint arg_fg_dispatch,
+    gint arg_focus_pgid)
+{
+  g_signal_emit_by_name (object, "transaction-event", arg_se_type, arg_aid, arg_param, arg_fg_dispatch, arg_focus_pgid);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_emit_rf_detected:
+ * @object: A #NetNfcGDbusSecureElement.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-SecureElement.RfDetected">"RfDetected"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_secure_element_emit_rf_detected (
+    NetNfcGDbusSecureElement *object)
+{
+  g_signal_emit_by_name (object, "rf-detected");
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Set">Set()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_set_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_set (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Set",
+    g_variant_new ("(i)",
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_set().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_set().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Set">Set()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_set() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Set",
+    g_variant_new ("(i)",
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Get">Get()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get (
+    NetNfcGDbusSecureElement *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Get",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Get">Get()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Get",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_card_emulation:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetCardEmulation">SetCardEmulation()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_set_card_emulation_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_card_emulation_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_set_card_emulation (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetCardEmulation",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_card_emulation_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_set_card_emulation().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_set_card_emulation().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_card_emulation_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_card_emulation_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetCardEmulation">SetCardEmulation()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_card_emulation() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_card_emulation_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetCardEmulation",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_card_emulation:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetCardEmulation">GetCardEmulation()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_card_emulation_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_card_emulation_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_card_emulation (
+    NetNfcGDbusSecureElement *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetCardEmulation",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_card_emulation_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_card_emulation().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_card_emulation().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_card_emulation_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_card_emulation_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetCardEmulation">GetCardEmulation()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_card_emulation() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_card_emulation_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetCardEmulation",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii)",
+                 out_result,
+                 out_type);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_open_secure_element:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.OpenSecureElement">OpenSecureElement()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_open_secure_element_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_open_secure_element_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_open_secure_element (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "OpenSecureElement",
+    g_variant_new ("(i)",
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_open_secure_element_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_open_secure_element().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_open_secure_element().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_open_secure_element_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    guint *out_handle,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_handle);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_open_secure_element_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handle: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.OpenSecureElement">OpenSecureElement()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_open_secure_element() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_open_secure_element_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    gint *out_result,
+    guint *out_handle,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "OpenSecureElement",
+    g_variant_new ("(i)",
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu)",
+                 out_result,
+                 out_handle);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_close_secure_element:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CloseSecureElement">CloseSecureElement()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_close_secure_element_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_close_secure_element_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_close_secure_element (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "CloseSecureElement",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_close_secure_element_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_close_secure_element().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_close_secure_element().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_close_secure_element_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_close_secure_element_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CloseSecureElement">CloseSecureElement()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_close_secure_element() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_close_secure_element_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "CloseSecureElement",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_atr:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetAtr">GetAtr()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_atr_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_atr_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_atr (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetAtr",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_atr_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_atr: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_atr().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_atr().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_atr_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_atr,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_atr);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_atr_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_atr: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetAtr">GetAtr()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_atr() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_atr_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GVariant **out_atr,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetAtr",
+    g_variant_new ("(u)",
+                   arg_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_atr);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_send_apdu:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SendAPDU">SendAPDU()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_send_apdu_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_send_apdu_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_send_apdu (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SendAPDU",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_send_apdu_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_response: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_send_apdu().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_send_apdu().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_send_apdu_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_response,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_response);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_send_apdu_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_response: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SendAPDU">SendAPDU()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_send_apdu() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_send_apdu_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GVariant **out_response,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SendAPDU",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_response);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetTransactionFgDispatch">SetTransactionFgDispatch()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetTransactionFgDispatch",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetTransactionFgDispatch">SetTransactionFgDispatch()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetTransactionFgDispatch",
+    g_variant_new ("(i)",
+                   arg_mode),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_default_route:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_switch_on: Argument to pass with the method invocation.
+ * @arg_switch_off: Argument to pass with the method invocation.
+ * @arg_battery_off: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetDefaultRoute">SetDefaultRoute()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_set_default_route_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_default_route_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_set_default_route (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_switch_on,
+    guint arg_switch_off,
+    guint arg_battery_off,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetDefaultRoute",
+    g_variant_new ("(uuu)",
+                   arg_switch_on,
+                   arg_switch_off,
+                   arg_battery_off),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_default_route_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_set_default_route().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_set_default_route().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_default_route_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_default_route_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_switch_on: Argument to pass with the method invocation.
+ * @arg_switch_off: Argument to pass with the method invocation.
+ * @arg_battery_off: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetDefaultRoute">SetDefaultRoute()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_default_route() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_default_route_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_switch_on,
+    guint arg_switch_off,
+    guint arg_battery_off,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetDefaultRoute",
+    g_variant_new ("(uuu)",
+                   arg_switch_on,
+                   arg_switch_off,
+                   arg_battery_off),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_preferred_handler:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_state: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetPreferredHandler">SetPreferredHandler()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_set_preferred_handler_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_preferred_handler_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_set_preferred_handler (
+    NetNfcGDbusSecureElement *proxy,
+    gboolean arg_state,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetPreferredHandler",
+    g_variant_new ("(b)",
+                   arg_state),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_preferred_handler_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_set_preferred_handler().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_set_preferred_handler().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_preferred_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_set_preferred_handler_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_state: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetPreferredHandler">SetPreferredHandler()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_set_preferred_handler() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_set_preferred_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gboolean arg_state,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetPreferredHandler",
+    g_variant_new ("(b)",
+                   arg_state),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_check_transaction_permission:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CheckTransactionPermission">CheckTransactionPermission()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_check_transaction_permission_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_check_transaction_permission_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_check_transaction_permission (
+    NetNfcGDbusSecureElement *proxy,
+    GVariant *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "CheckTransactionPermission",
+    g_variant_new ("(@a(y))",
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_check_transaction_permission_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_check_transaction_permission().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_check_transaction_permission().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_check_transaction_permission_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_check_transaction_permission_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CheckTransactionPermission">CheckTransactionPermission()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_check_transaction_permission() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_check_transaction_permission_sync (
+    NetNfcGDbusSecureElement *proxy,
+    GVariant *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "CheckTransactionPermission",
+    g_variant_new ("(@a(y))",
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_aid_handler:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedAidHandler">IsActivatedAidHandler()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_is_activated_aid_handler_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_is_activated_aid_handler_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_is_activated_aid_handler (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "IsActivatedAidHandler",
+    g_variant_new ("(us)",
+                   arg_type,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_aid_handler_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_activated: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_is_activated_aid_handler().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_is_activated_aid_handler().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_is_activated_aid_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gboolean *out_activated,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ib)",
+                 out_result,
+                 out_activated);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_aid_handler_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_activated: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedAidHandler">IsActivatedAidHandler()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_is_activated_aid_handler() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_is_activated_aid_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    const gchar *arg_aid,
+    gint *out_result,
+    gboolean *out_activated,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "IsActivatedAidHandler",
+    g_variant_new ("(us)",
+                   arg_type,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ib)",
+                 out_result,
+                 out_activated);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_category_handler:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedCategoryHandler">IsActivatedCategoryHandler()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_is_activated_category_handler_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_is_activated_category_handler_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_is_activated_category_handler (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "IsActivatedCategoryHandler",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_category_handler_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_activated: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_is_activated_category_handler().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_is_activated_category_handler().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_is_activated_category_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gboolean *out_activated,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ib)",
+                 out_result,
+                 out_activated);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_is_activated_category_handler_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_activated: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedCategoryHandler">IsActivatedCategoryHandler()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_is_activated_category_handler() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_is_activated_category_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    gboolean *out_activated,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "IsActivatedCategoryHandler",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ib)",
+                 out_result,
+                 out_activated);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_aids:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredAids">GetRegisteredAids()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_registered_aids_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_registered_aids_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_registered_aids (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetRegisteredAids",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_aids_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_aids: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_registered_aids().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_registered_aids().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_registered_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_aids,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(sb))",
+                 out_result,
+                 out_aids);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_aids_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_aids: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredAids">GetRegisteredAids()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_registered_aids() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_registered_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    GVariant **out_aids,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetRegisteredAids",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(sb))",
+                 out_result,
+                 out_aids);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_register_aid:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RegisterAid">RegisterAid()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_register_aid_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_register_aid_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_register_aid (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "RegisterAid",
+    g_variant_new ("(uus)",
+                   arg_type,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_register_aid_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_register_aid().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_register_aid().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_register_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_register_aid_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RegisterAid">RegisterAid()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_register_aid() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_register_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "RegisterAid",
+    g_variant_new ("(uus)",
+                   arg_type,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aid:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAid">UnregisterAid()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_unregister_aid_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_unregister_aid_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_unregister_aid (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "UnregisterAid",
+    g_variant_new ("(uus)",
+                   arg_type,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aid_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_unregister_aid().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_unregister_aid().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_unregister_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aid_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAid">UnregisterAid()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_unregister_aid() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_unregister_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "UnregisterAid",
+    g_variant_new ("(uus)",
+                   arg_type,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aids:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAids">UnregisterAids()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_unregister_aids_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_unregister_aids_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_unregister_aids (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "UnregisterAids",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aids_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_unregister_aids().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_unregister_aids().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_unregister_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_unregister_aids_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAids">UnregisterAids()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_unregister_aids() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_unregister_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "UnregisterAids",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_add_route_aid:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @arg_se_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_unlock: Argument to pass with the method invocation.
+ * @arg_power: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.AddRouteAid">AddRouteAid()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_add_route_aid_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_add_route_aid_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_add_route_aid (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    guint arg_se_type,
+    guint arg_category,
+    gboolean arg_unlock,
+    guint arg_power,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "AddRouteAid",
+    g_variant_new ("(ssuubu)",
+                   arg_package,
+                   arg_aid,
+                   arg_se_type,
+                   arg_category,
+                   arg_unlock,
+                   arg_power),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_add_route_aid_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_add_route_aid().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_add_route_aid().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_add_route_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_add_route_aid_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @arg_se_type: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_unlock: Argument to pass with the method invocation.
+ * @arg_power: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.AddRouteAid">AddRouteAid()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_add_route_aid() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_add_route_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    guint arg_se_type,
+    guint arg_category,
+    gboolean arg_unlock,
+    guint arg_power,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "AddRouteAid",
+    g_variant_new ("(ssuubu)",
+                   arg_package,
+                   arg_aid,
+                   arg_se_type,
+                   arg_category,
+                   arg_unlock,
+                   arg_power),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_route_aid:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemoveRouteAid">RemoveRouteAid()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_remove_route_aid_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_remove_route_aid_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_remove_route_aid (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "RemoveRouteAid",
+    g_variant_new ("(ss)",
+                   arg_package,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_route_aid_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_remove_route_aid().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_remove_route_aid().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_remove_route_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_route_aid_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemoveRouteAid">RemoveRouteAid()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_remove_route_aid() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_remove_route_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "RemoveRouteAid",
+    g_variant_new ("(ss)",
+                   arg_package,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_package_aids:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemovePackageAids">RemovePackageAids()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_remove_package_aids_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_remove_package_aids_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_remove_package_aids (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "RemovePackageAids",
+    g_variant_new ("(s)",
+                   arg_package),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_package_aids_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_remove_package_aids().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_remove_package_aids().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_remove_package_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_remove_package_aids_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemovePackageAids">RemovePackageAids()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_remove_package_aids() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_remove_package_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "RemovePackageAids",
+    g_variant_new ("(s)",
+                   arg_package),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_handlers:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_category: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredHandlers">GetRegisteredHandlers()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_registered_handlers_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_registered_handlers_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_registered_handlers (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetRegisteredHandlers",
+    g_variant_new ("(u)",
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_handlers_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_packages: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_registered_handlers().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_registered_handlers().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_registered_handlers_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_packages,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(is))",
+                 out_result,
+                 out_packages);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_registered_handlers_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_category: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_packages: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredHandlers">GetRegisteredHandlers()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_registered_handlers() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_registered_handlers_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    gint *out_result,
+    GVariant **out_packages,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetRegisteredHandlers",
+    g_variant_new ("(u)",
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(is))",
+                 out_result,
+                 out_packages);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_handler_storage_info:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_category: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetHandlerStorageInfo">GetHandlerStorageInfo()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_handler_storage_info_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_handler_storage_info_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_handler_storage_info (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetHandlerStorageInfo",
+    g_variant_new ("(u)",
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_handler_storage_info_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_used: (out): Return location for return parameter or %NULL to ignore.
+ * @out_maximum: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_handler_storage_info().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_handler_storage_info().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_handler_storage_info_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_used,
+    gint *out_maximum,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iii)",
+                 out_result,
+                 out_used,
+                 out_maximum);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_handler_storage_info_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_category: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_used: (out): Return location for return parameter or %NULL to ignore.
+ * @out_maximum: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetHandlerStorageInfo">GetHandlerStorageInfo()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_handler_storage_info() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_handler_storage_info_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    gint *out_result,
+    gint *out_used,
+    gint *out_maximum,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetHandlerStorageInfo",
+    g_variant_new ("(u)",
+                   arg_category),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iii)",
+                 out_result,
+                 out_used,
+                 out_maximum);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_conflict_handlers:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetConflictHandlers">GetConflictHandlers()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_call_get_conflict_handlers_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_conflict_handlers_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_secure_element_call_get_conflict_handlers (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetConflictHandlers",
+    g_variant_new ("(sus)",
+                   arg_package,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_conflict_handlers_finish:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_packages: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_call_get_conflict_handlers().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_call_get_conflict_handlers().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_conflict_handlers_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_packages,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(s))",
+                 out_result,
+                 out_packages);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_call_get_conflict_handlers_sync:
+ * @proxy: A #NetNfcGDbusSecureElementProxy.
+ * @arg_package: Argument to pass with the method invocation.
+ * @arg_category: Argument to pass with the method invocation.
+ * @arg_aid: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_packages: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetConflictHandlers">GetConflictHandlers()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_call_get_conflict_handlers() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_secure_element_call_get_conflict_handlers_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GVariant **out_packages,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetConflictHandlers",
+    g_variant_new ("(sus)",
+                   arg_package,
+                   arg_category,
+                   arg_aid),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(s))",
+                 out_result,
+                 out_packages);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_set:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_set (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @type: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.Get">Get()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint type)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ii)",
+                   result,
+                   type));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_set_card_emulation:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetCardEmulation">SetCardEmulation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_set_card_emulation (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_card_emulation:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @type: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetCardEmulation">GetCardEmulation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_card_emulation (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint type)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ii)",
+                   result,
+                   type));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_open_secure_element:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @handle: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.OpenSecureElement">OpenSecureElement()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_open_secure_element (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint handle)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu)",
+                   result,
+                   handle));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_close_secure_element:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CloseSecureElement">CloseSecureElement()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_close_secure_element (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_atr:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @atr: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetAtr">GetAtr()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_atr (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *atr)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   atr));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_send_apdu:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @response: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SendAPDU">SendAPDU()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_send_apdu (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *response)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   response));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_set_transaction_fg_dispatch:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetTransactionFgDispatch">SetTransactionFgDispatch()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_set_transaction_fg_dispatch (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_set_default_route:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetDefaultRoute">SetDefaultRoute()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_set_default_route (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_set_preferred_handler:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.SetPreferredHandler">SetPreferredHandler()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_set_preferred_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_check_transaction_permission:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.CheckTransactionPermission">CheckTransactionPermission()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_check_transaction_permission (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_is_activated_aid_handler:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @activated: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedAidHandler">IsActivatedAidHandler()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_is_activated_aid_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean activated)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ib)",
+                   result,
+                   activated));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_is_activated_category_handler:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @activated: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.IsActivatedCategoryHandler">IsActivatedCategoryHandler()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_is_activated_category_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean activated)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ib)",
+                   result,
+                   activated));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_registered_aids:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @aids: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredAids">GetRegisteredAids()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_registered_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *aids)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(sb))",
+                   result,
+                   aids));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_register_aid:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RegisterAid">RegisterAid()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_register_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_unregister_aid:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAid">UnregisterAid()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_unregister_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_unregister_aids:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.UnregisterAids">UnregisterAids()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_unregister_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_add_route_aid:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.AddRouteAid">AddRouteAid()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_add_route_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_remove_route_aid:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemoveRouteAid">RemoveRouteAid()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_remove_route_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_remove_package_aids:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.RemovePackageAids">RemovePackageAids()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_remove_package_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_registered_handlers:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @packages: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetRegisteredHandlers">GetRegisteredHandlers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_registered_handlers (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *packages)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(is))",
+                   result,
+                   packages));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_handler_storage_info:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @used: Parameter to return.
+ * @maximum: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetHandlerStorageInfo">GetHandlerStorageInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_handler_storage_info (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint used,
+    gint maximum)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iii)",
+                   result,
+                   used,
+                   maximum));
+}
+
+/**
+ * net_nfc_gdbus_secure_element_complete_get_conflict_handlers:
+ * @object: A #NetNfcGDbusSecureElement.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @packages: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-SecureElement.GetConflictHandlers">GetConflictHandlers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_secure_element_complete_get_conflict_handlers (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *packages)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(s))",
+                   result,
+                   packages));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusSecureElementProxy:
+ *
+ * The #NetNfcGDbusSecureElementProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusSecureElementProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusSecureElementProxy.
+ */
+
+struct _NetNfcGDbusSecureElementProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_secure_element_proxy_iface_init (NetNfcGDbusSecureElementIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSecureElementProxy, net_nfc_gdbus_secure_element_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusSecureElementProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, net_nfc_gdbus_secure_element_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSecureElementProxy, net_nfc_gdbus_secure_element_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, net_nfc_gdbus_secure_element_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_secure_element_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusSecureElementProxy *proxy = NET_NFC_GDBUS_SECURE_ELEMENT_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_secure_element_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_SECURE_ELEMENT);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_SECURE_ELEMENT);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusSecureElementProxy *proxy = NET_NFC_GDBUS_SECURE_ELEMENT_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_init (NetNfcGDbusSecureElementProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_secure_element_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, NetNfcGDbusSecureElementProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_secure_element_interface_info ());
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_class_init (NetNfcGDbusSecureElementProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_secure_element_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_secure_element_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_secure_element_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_secure_element_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_secure_element_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusSecureElementProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_secure_element_proxy_iface_init (NetNfcGDbusSecureElementIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_secure_element_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.SecureElement", NULL);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSecureElementProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSecureElement *
+net_nfc_gdbus_secure_element_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SECURE_ELEMENT (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSecureElementProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSecureElement *
+net_nfc_gdbus_secure_element_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.SecureElement", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SECURE_ELEMENT (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_secure_element_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_secure_element_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_secure_element_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_secure_element_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.SecureElement", NULL);
+}
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_secure_element_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_secure_element_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSecureElementProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSecureElement *
+net_nfc_gdbus_secure_element_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SECURE_ELEMENT (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_secure_element_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_secure_element_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSecureElementProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSecureElement *
+net_nfc_gdbus_secure_element_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.SecureElement", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SECURE_ELEMENT (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusSecureElementSkeleton:
+ *
+ * The #NetNfcGDbusSecureElementSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusSecureElementSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusSecureElementSkeleton.
+ */
+
+struct _NetNfcGDbusSecureElementSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_secure_element_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_SECURE_ELEMENT);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_SECURE_ELEMENT);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_secure_element_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_secure_element_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_secure_element_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_secure_element_skeleton_vtable =
+{
+  _net_nfc_gdbus_secure_element_skeleton_handle_method_call,
+  _net_nfc_gdbus_secure_element_skeleton_handle_get_property,
+  _net_nfc_gdbus_secure_element_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_secure_element_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_secure_element_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_secure_element_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_secure_element_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_secure_element_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_secure_element_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_secure_element_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_secure_element_on_signal_ese_detected (
+    NetNfcGDbusSecureElement *object,
+    guint arg_handle,
+    gint arg_se_type,
+    GVariant *arg_data)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(ui@a(y))",
+                   arg_handle,
+                   arg_se_type,
+                   arg_data));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", "EseDetected",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_secure_element_on_signal_se_type_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(i)",
+                   arg_se_type));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", "SeTypeChanged",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_secure_element_on_signal_card_emulation_mode_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_mode)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(i)",
+                   arg_mode));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", "CardEmulationModeChanged",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_secure_element_on_signal_transaction_event (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type,
+    GVariant *arg_aid,
+    GVariant *arg_param,
+    gint arg_fg_dispatch,
+    gint arg_focus_pgid)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(i@a(y)@a(y)ii)",
+                   arg_se_type,
+                   arg_aid,
+                   arg_param,
+                   arg_fg_dispatch,
+                   arg_focus_pgid));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", "TransactionEvent",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_secure_element_on_signal_rf_detected (
+    NetNfcGDbusSecureElement *object)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("()"));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.SecureElement", "RfDetected",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_secure_element_skeleton_iface_init (NetNfcGDbusSecureElementIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSecureElementSkeleton, net_nfc_gdbus_secure_element_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusSecureElementSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, net_nfc_gdbus_secure_element_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSecureElementSkeleton, net_nfc_gdbus_secure_element_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, net_nfc_gdbus_secure_element_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_secure_element_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusSecureElementSkeleton *skeleton = NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_secure_element_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_secure_element_skeleton_init (NetNfcGDbusSecureElementSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_secure_element_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON, NetNfcGDbusSecureElementSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_secure_element_skeleton_class_init (NetNfcGDbusSecureElementSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_secure_element_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_secure_element_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_secure_element_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusSecureElementSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_secure_element_skeleton_iface_init (NetNfcGDbusSecureElementIface *iface)
+{
+  iface->ese_detected = _net_nfc_gdbus_secure_element_on_signal_ese_detected;
+  iface->se_type_changed = _net_nfc_gdbus_secure_element_on_signal_se_type_changed;
+  iface->card_emulation_mode_changed = _net_nfc_gdbus_secure_element_on_signal_card_emulation_mode_changed;
+  iface->transaction_event = _net_nfc_gdbus_secure_element_on_signal_transaction_event;
+  iface->rf_detected = _net_nfc_gdbus_secure_element_on_signal_rf_detected;
+}
+
+/**
+ * net_nfc_gdbus_secure_element_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-SecureElement.top_of_page">org.tizen.NetNfcService.SecureElement</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSecureElementSkeleton): The skeleton object.
+ */
+NetNfcGDbusSecureElement *
+net_nfc_gdbus_secure_element_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_SECURE_ELEMENT (g_object_new (NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Transceive
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusTransceive
+ * @title: NetNfcGDbusTransceive
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Transceive D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Transceive ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_handle,
+  &_net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_dev_type,
+  &_net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_resp_data =
+{
+  {
+    -1,
+    (gchar *) "resp_data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_result,
+  &_net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_resp_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_transceive_method_info_transceive_data =
+{
+  {
+    -1,
+    (gchar *) "TransceiveData",
+    (GDBusArgInfo **) &_net_nfc_gdbus_transceive_method_info_transceive_data_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_transceive_method_info_transceive_data_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-transceive-data",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_dev_type =
+{
+  {
+    -1,
+    (gchar *) "dev_type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_handle,
+  &_net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_dev_type,
+  &_net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_transceive_method_info_transceive_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_transceive_method_info_transceive_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_transceive_method_info_transceive_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_transceive_method_info_transceive =
+{
+  {
+    -1,
+    (gchar *) "Transceive",
+    (GDBusArgInfo **) &_net_nfc_gdbus_transceive_method_info_transceive_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_transceive_method_info_transceive_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-transceive",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_transceive_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_transceive_method_info_transceive_data,
+  &_net_nfc_gdbus_transceive_method_info_transceive,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_transceive_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Transceive",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_transceive_method_info_pointers,
+    NULL,
+    NULL,
+    NULL
+  },
+  "transceive",
+};
+
+
+/**
+ * net_nfc_gdbus_transceive_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_transceive_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_transceive_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusTransceive interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_transceive_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusTransceive:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link>.
+ */
+
+/**
+ * NetNfcGDbusTransceiveIface:
+ * @parent_iface: The parent interface.
+ * @handle_transceive: Handler for the #NetNfcGDbusTransceive::handle-transceive signal.
+ * @handle_transceive_data: Handler for the #NetNfcGDbusTransceive::handle-transceive-data signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link>.
+ */
+
+typedef NetNfcGDbusTransceiveIface NetNfcGDbusTransceiveInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusTransceive, net_nfc_gdbus_transceive, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_transceive_default_init (NetNfcGDbusTransceiveIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusTransceive::handle-transceive-data:
+   * @object: A #NetNfcGDbusTransceive.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_dev_type: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.TransceiveData">TransceiveData()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_transceive_complete_transceive_data() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-transceive-data",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTransceiveIface, handle_transceive_data),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusTransceive::handle-transceive:
+   * @object: A #NetNfcGDbusTransceive.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_dev_type: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.Transceive">Transceive()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_transceive_complete_transceive() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-transceive",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTransceiveIface, handle_transceive),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive_data:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_dev_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.TransceiveData">TransceiveData()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_transceive_call_transceive_data_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_transceive_call_transceive_data_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_transceive_call_transceive_data (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "TransceiveData",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_dev_type,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive_data_finish:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_resp_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_transceive_call_transceive_data().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_transceive_call_transceive_data().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_transceive_call_transceive_data_finish (
+    NetNfcGDbusTransceive *proxy,
+    gint *out_result,
+    GVariant **out_resp_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_resp_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive_data_sync:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_dev_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_resp_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.TransceiveData">TransceiveData()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_transceive_call_transceive_data() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_transceive_call_transceive_data_sync (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    gint *out_result,
+    GVariant **out_resp_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "TransceiveData",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_dev_type,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i@a(y))",
+                 out_result,
+                 out_resp_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_dev_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.Transceive">Transceive()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_transceive_call_transceive_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_transceive_call_transceive_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_transceive_call_transceive (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Transceive",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_dev_type,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive_finish:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_transceive_call_transceive().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_transceive_call_transceive().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_transceive_call_transceive_finish (
+    NetNfcGDbusTransceive *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_call_transceive_sync:
+ * @proxy: A #NetNfcGDbusTransceiveProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_dev_type: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.Transceive">Transceive()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_transceive_call_transceive() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_transceive_call_transceive_sync (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Transceive",
+    g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_dev_type,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_complete_transceive_data:
+ * @object: A #NetNfcGDbusTransceive.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @resp_data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.TransceiveData">TransceiveData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_transceive_complete_transceive_data (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *resp_data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i@a(y))",
+                   result,
+                   resp_data));
+}
+
+/**
+ * net_nfc_gdbus_transceive_complete_transceive:
+ * @object: A #NetNfcGDbusTransceive.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Transceive.Transceive">Transceive()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_transceive_complete_transceive (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTransceiveProxy:
+ *
+ * The #NetNfcGDbusTransceiveProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTransceiveProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTransceiveProxy.
+ */
+
+struct _NetNfcGDbusTransceiveProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_transceive_proxy_iface_init (NetNfcGDbusTransceiveIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTransceiveProxy, net_nfc_gdbus_transceive_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusTransceiveProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TRANSCEIVE, net_nfc_gdbus_transceive_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTransceiveProxy, net_nfc_gdbus_transceive_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TRANSCEIVE, net_nfc_gdbus_transceive_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_transceive_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusTransceiveProxy *proxy = NET_NFC_GDBUS_TRANSCEIVE_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_transceive_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_TRANSCEIVE);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TRANSCEIVE);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusTransceiveProxy *proxy = NET_NFC_GDBUS_TRANSCEIVE_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_init (NetNfcGDbusTransceiveProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_transceive_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, NetNfcGDbusTransceiveProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_transceive_interface_info ());
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_class_init (NetNfcGDbusTransceiveProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_transceive_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_transceive_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_transceive_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_transceive_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_transceive_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTransceiveProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_transceive_proxy_iface_init (NetNfcGDbusTransceiveIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_transceive_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_transceive_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_transceive_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Transceive", NULL);
+}
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_transceive_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_transceive_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTransceiveProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTransceive *
+net_nfc_gdbus_transceive_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TRANSCEIVE (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_transceive_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTransceiveProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTransceive *
+net_nfc_gdbus_transceive_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Transceive", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TRANSCEIVE (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_transceive_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_transceive_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_transceive_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_transceive_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Transceive", NULL);
+}
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_transceive_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_transceive_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTransceiveProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTransceive *
+net_nfc_gdbus_transceive_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TRANSCEIVE (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_transceive_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_transceive_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_transceive_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTransceiveProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTransceive *
+net_nfc_gdbus_transceive_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Transceive", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TRANSCEIVE (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTransceiveSkeleton:
+ *
+ * The #NetNfcGDbusTransceiveSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTransceiveSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTransceiveSkeleton.
+ */
+
+struct _NetNfcGDbusTransceiveSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_transceive_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusTransceiveSkeleton *skeleton = NET_NFC_GDBUS_TRANSCEIVE_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_TRANSCEIVE);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TRANSCEIVE);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_transceive_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTransceiveSkeleton *skeleton = NET_NFC_GDBUS_TRANSCEIVE_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_transceive_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTransceiveSkeleton *skeleton = NET_NFC_GDBUS_TRANSCEIVE_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_transceive_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_transceive_skeleton_vtable =
+{
+  _net_nfc_gdbus_transceive_skeleton_handle_method_call,
+  _net_nfc_gdbus_transceive_skeleton_handle_get_property,
+  _net_nfc_gdbus_transceive_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_transceive_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_transceive_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_transceive_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_transceive_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_transceive_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusTransceiveSkeleton *skeleton = NET_NFC_GDBUS_TRANSCEIVE_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_transceive_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_transceive_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_transceive_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_transceive_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Transceive", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_transceive_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void net_nfc_gdbus_transceive_skeleton_iface_init (NetNfcGDbusTransceiveIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTransceiveSkeleton, net_nfc_gdbus_transceive_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusTransceiveSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TRANSCEIVE, net_nfc_gdbus_transceive_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTransceiveSkeleton, net_nfc_gdbus_transceive_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TRANSCEIVE, net_nfc_gdbus_transceive_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_transceive_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusTransceiveSkeleton *skeleton = NET_NFC_GDBUS_TRANSCEIVE_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_transceive_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_transceive_skeleton_init (NetNfcGDbusTransceiveSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_transceive_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON, NetNfcGDbusTransceiveSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_transceive_skeleton_class_init (NetNfcGDbusTransceiveSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_transceive_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_transceive_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_transceive_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_transceive_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_transceive_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTransceiveSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_transceive_skeleton_iface_init (NetNfcGDbusTransceiveIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_transceive_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Transceive.top_of_page">org.tizen.NetNfcService.Transceive</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTransceiveSkeleton): The skeleton object.
+ */
+NetNfcGDbusTransceive *
+net_nfc_gdbus_transceive_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_TRANSCEIVE (g_object_new (NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Handover
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusHandover
+ * @title: NetNfcGDbusHandover
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Handover D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Handover ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_method_info_request_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_method_info_request_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_handover_method_info_request_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_handover_method_info_request_IN_ARG_handle,
+  &_net_nfc_gdbus_handover_method_info_request_IN_ARG_type,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_method_info_request_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_method_info_request_OUT_ARG_carrier_type =
+{
+  {
+    -1,
+    (gchar *) "carrier_type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_method_info_request_OUT_ARG_handover_data =
+{
+  {
+    -1,
+    (gchar *) "handover_data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_handover_method_info_request_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_handover_method_info_request_OUT_ARG_result,
+  &_net_nfc_gdbus_handover_method_info_request_OUT_ARG_carrier_type,
+  &_net_nfc_gdbus_handover_method_info_request_OUT_ARG_handover_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_handover_method_info_request =
+{
+  {
+    -1,
+    (gchar *) "Request",
+    (GDBusArgInfo **) &_net_nfc_gdbus_handover_method_info_request_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_handover_method_info_request_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-request",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_handover_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_handover_method_info_request,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_signal_info_started_ARG_message =
+{
+  {
+    -1,
+    (gchar *) "message",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_handover_signal_info_started_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_handover_signal_info_started_ARG_message,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_handover_signal_info_started =
+{
+  {
+    -1,
+    (gchar *) "Started",
+    (GDBusArgInfo **) &_net_nfc_gdbus_handover_signal_info_started_ARG_pointers,
+    NULL
+  },
+  "started"
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_signal_info_finished_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_signal_info_finished_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_signal_info_finished_ARG_address =
+{
+  {
+    -1,
+    (gchar *) "address",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_handover_signal_info_finished_ARG_message =
+{
+  {
+    -1,
+    (gchar *) "message",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_handover_signal_info_finished_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_handover_signal_info_finished_ARG_result,
+  &_net_nfc_gdbus_handover_signal_info_finished_ARG_type,
+  &_net_nfc_gdbus_handover_signal_info_finished_ARG_address,
+  &_net_nfc_gdbus_handover_signal_info_finished_ARG_message,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_handover_signal_info_finished =
+{
+  {
+    -1,
+    (gchar *) "Finished",
+    (GDBusArgInfo **) &_net_nfc_gdbus_handover_signal_info_finished_ARG_pointers,
+    NULL
+  },
+  "finished"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_handover_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_handover_signal_info_started,
+  &_net_nfc_gdbus_handover_signal_info_finished,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_handover_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Handover",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_handover_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_handover_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "handover",
+};
+
+
+/**
+ * net_nfc_gdbus_handover_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_handover_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_handover_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusHandover interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_handover_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusHandover:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link>.
+ */
+
+/**
+ * NetNfcGDbusHandoverIface:
+ * @parent_iface: The parent interface.
+ * @handle_request: Handler for the #NetNfcGDbusHandover::handle-request signal.
+ * @finished: Handler for the #NetNfcGDbusHandover::finished signal.
+ * @started: Handler for the #NetNfcGDbusHandover::started signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link>.
+ */
+
+typedef NetNfcGDbusHandoverIface NetNfcGDbusHandoverInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusHandover, net_nfc_gdbus_handover, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_handover_default_init (NetNfcGDbusHandoverIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusHandover::handle-request:
+   * @object: A #NetNfcGDbusHandover.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_type: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Handover.Request">Request()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_handover_complete_request() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-request",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHandoverIface, handle_request),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusHandover::started:
+   * @object: A #NetNfcGDbusHandover.
+   * @arg_message: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Handover.Started">"Started"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("started",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHandoverIface, started),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    1, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusHandover::finished:
+   * @object: A #NetNfcGDbusHandover.
+   * @arg_result: Argument.
+   * @arg_type: Argument.
+   * @arg_address: Argument.
+   * @arg_message: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Handover.Finished">"Finished"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("finished",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHandoverIface, finished),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    4, G_TYPE_INT, G_TYPE_INT, G_TYPE_VARIANT, G_TYPE_VARIANT);
+
+}
+
+/**
+ * net_nfc_gdbus_handover_emit_started:
+ * @object: A #NetNfcGDbusHandover.
+ * @arg_message: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Handover.Started">"Started"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_handover_emit_started (
+    NetNfcGDbusHandover *object,
+    GVariant *arg_message)
+{
+  g_signal_emit_by_name (object, "started", arg_message);
+}
+
+/**
+ * net_nfc_gdbus_handover_emit_finished:
+ * @object: A #NetNfcGDbusHandover.
+ * @arg_result: Argument to pass with the signal.
+ * @arg_type: Argument to pass with the signal.
+ * @arg_address: Argument to pass with the signal.
+ * @arg_message: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Handover.Finished">"Finished"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_handover_emit_finished (
+    NetNfcGDbusHandover *object,
+    gint arg_result,
+    gint arg_type,
+    GVariant *arg_address,
+    GVariant *arg_message)
+{
+  g_signal_emit_by_name (object, "finished", arg_result, arg_type, arg_address, arg_message);
+}
+
+/**
+ * net_nfc_gdbus_handover_call_request:
+ * @proxy: A #NetNfcGDbusHandoverProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Handover.Request">Request()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_handover_call_request_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_handover_call_request_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_handover_call_request (
+    NetNfcGDbusHandover *proxy,
+    guint arg_handle,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "Request",
+    g_variant_new ("(ui)",
+                   arg_handle,
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_handover_call_request_finish:
+ * @proxy: A #NetNfcGDbusHandoverProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_carrier_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handover_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_handover_call_request().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_handover_call_request().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_handover_call_request_finish (
+    NetNfcGDbusHandover *proxy,
+    gint *out_result,
+    gint *out_carrier_type,
+    GVariant **out_handover_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii@a(y))",
+                 out_result,
+                 out_carrier_type,
+                 out_handover_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_handover_call_request_sync:
+ * @proxy: A #NetNfcGDbusHandoverProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_carrier_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_handover_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Handover.Request">Request()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_handover_call_request() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_handover_call_request_sync (
+    NetNfcGDbusHandover *proxy,
+    guint arg_handle,
+    gint arg_type,
+    gint *out_result,
+    gint *out_carrier_type,
+    GVariant **out_handover_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "Request",
+    g_variant_new ("(ui)",
+                   arg_handle,
+                   arg_type),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(ii@a(y))",
+                 out_result,
+                 out_carrier_type,
+                 out_handover_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_handover_complete_request:
+ * @object: A #NetNfcGDbusHandover.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @carrier_type: Parameter to return.
+ * @handover_data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Handover.Request">Request()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_handover_complete_request (
+    NetNfcGDbusHandover *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint carrier_type,
+    GVariant *handover_data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(ii@a(y))",
+                   result,
+                   carrier_type,
+                   handover_data));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusHandoverProxy:
+ *
+ * The #NetNfcGDbusHandoverProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusHandoverProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusHandoverProxy.
+ */
+
+struct _NetNfcGDbusHandoverProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_handover_proxy_iface_init (NetNfcGDbusHandoverIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHandoverProxy, net_nfc_gdbus_handover_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusHandoverProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HANDOVER, net_nfc_gdbus_handover_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHandoverProxy, net_nfc_gdbus_handover_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HANDOVER, net_nfc_gdbus_handover_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_handover_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusHandoverProxy *proxy = NET_NFC_GDBUS_HANDOVER_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_handover_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_handover_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_handover_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_handover_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_HANDOVER);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_HANDOVER);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_handover_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusHandoverProxy *proxy = NET_NFC_GDBUS_HANDOVER_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_handover_proxy_init (NetNfcGDbusHandoverProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_handover_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, NetNfcGDbusHandoverProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_handover_interface_info ());
+}
+
+static void
+net_nfc_gdbus_handover_proxy_class_init (NetNfcGDbusHandoverProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_handover_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_handover_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_handover_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_handover_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_handover_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusHandoverProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_handover_proxy_iface_init (NetNfcGDbusHandoverIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_handover_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_handover_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_handover_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_handover_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Handover", NULL);
+}
+
+/**
+ * net_nfc_gdbus_handover_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_handover_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_handover_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHandoverProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHandover *
+net_nfc_gdbus_handover_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HANDOVER (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_handover_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_handover_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHandoverProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHandover *
+net_nfc_gdbus_handover_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Handover", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HANDOVER (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_handover_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_handover_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_handover_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_handover_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_handover_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Handover", NULL);
+}
+
+/**
+ * net_nfc_gdbus_handover_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_handover_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_handover_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHandoverProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHandover *
+net_nfc_gdbus_handover_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HANDOVER (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_handover_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_handover_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_handover_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHandoverProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHandover *
+net_nfc_gdbus_handover_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Handover", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HANDOVER (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusHandoverSkeleton:
+ *
+ * The #NetNfcGDbusHandoverSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusHandoverSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusHandoverSkeleton.
+ */
+
+struct _NetNfcGDbusHandoverSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_handover_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_HANDOVER);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_HANDOVER);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_handover_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_handover_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_handover_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_handover_skeleton_vtable =
+{
+  _net_nfc_gdbus_handover_skeleton_handle_method_call,
+  _net_nfc_gdbus_handover_skeleton_handle_get_property,
+  _net_nfc_gdbus_handover_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_handover_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_handover_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_handover_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_handover_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_handover_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_handover_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_handover_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_handover_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_handover_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Handover", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_handover_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_handover_on_signal_started (
+    NetNfcGDbusHandover *object,
+    GVariant *arg_message)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(@a(y))",
+                   arg_message));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Handover", "Started",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void
+_net_nfc_gdbus_handover_on_signal_finished (
+    NetNfcGDbusHandover *object,
+    gint arg_result,
+    gint arg_type,
+    GVariant *arg_address,
+    GVariant *arg_message)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(ii@a(y)@a(y))",
+                   arg_result,
+                   arg_type,
+                   arg_address,
+                   arg_message));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Handover", "Finished",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_handover_skeleton_iface_init (NetNfcGDbusHandoverIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHandoverSkeleton, net_nfc_gdbus_handover_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusHandoverSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HANDOVER, net_nfc_gdbus_handover_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHandoverSkeleton, net_nfc_gdbus_handover_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HANDOVER, net_nfc_gdbus_handover_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_handover_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusHandoverSkeleton *skeleton = NET_NFC_GDBUS_HANDOVER_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_handover_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_handover_skeleton_init (NetNfcGDbusHandoverSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_handover_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON, NetNfcGDbusHandoverSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_handover_skeleton_class_init (NetNfcGDbusHandoverSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_handover_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_handover_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_handover_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_handover_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_handover_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusHandoverSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_handover_skeleton_iface_init (NetNfcGDbusHandoverIface *iface)
+{
+  iface->started = _net_nfc_gdbus_handover_on_signal_started;
+  iface->finished = _net_nfc_gdbus_handover_on_signal_finished;
+}
+
+/**
+ * net_nfc_gdbus_handover_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Handover.top_of_page">org.tizen.NetNfcService.Handover</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHandoverSkeleton): The skeleton object.
+ */
+NetNfcGDbusHandover *
+net_nfc_gdbus_handover_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_HANDOVER (g_object_new (NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Test
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusTest
+ * @title: NetNfcGDbusTest
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Test D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Test ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_sim_test_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_sim_test_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_sim_test_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_sim_test =
+{
+  {
+    -1,
+    (gchar *) "SimTest",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_sim_test_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-sim-test",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_tech =
+{
+  {
+    -1,
+    (gchar *) "tech",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_rate =
+{
+  {
+    -1,
+    (gchar *) "rate",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_tech,
+  &_net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_rate,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_prbs_test_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_prbs_test_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_prbs_test_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_prbs_test =
+{
+  {
+    -1,
+    (gchar *) "PrbsTest",
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_prbs_test_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_prbs_test_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-prbs-test",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_version =
+{
+  {
+    -1,
+    (gchar *) "version",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_result,
+  &_net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_version,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_get_firmware_version =
+{
+  {
+    -1,
+    (gchar *) "GetFirmwareVersion",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_get_firmware_version_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-get-firmware-version",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_mode =
+{
+  {
+    -1,
+    (gchar *) "mode",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_reg_id =
+{
+  {
+    -1,
+    (gchar *) "reg_id",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_mode,
+  &_net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_reg_id,
+  &_net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_ee_data_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_ee_data_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_ee_data_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_set_ee_data =
+{
+  {
+    -1,
+    (gchar *) "SetEeData",
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_ee_data_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_ee_data_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-ee-data",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_ese_test_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_ese_test_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_ese_test_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_ese_test =
+{
+  {
+    -1,
+    (gchar *) "EseTest",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_ese_test_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-ese-test",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_tech =
+{
+  {
+    -1,
+    (gchar *) "tech",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_type,
+  &_net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_tech,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_se_tech_type_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_se_tech_type_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_se_tech_type_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_set_se_tech_type =
+{
+  {
+    -1,
+    (gchar *) "SetSeTechType",
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_se_tech_type_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_se_tech_type_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-se-tech-type",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_listen_tech_mask_IN_ARG_tech =
+{
+  {
+    -1,
+    (gchar *) "tech",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_listen_tech_mask_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_listen_tech_mask_IN_ARG_tech,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_test_method_info_set_listen_tech_mask_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_test_method_info_set_listen_tech_mask_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_set_listen_tech_mask_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_test_method_info_set_listen_tech_mask =
+{
+  {
+    -1,
+    (gchar *) "SetListenTechMask",
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_listen_tech_mask_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_test_method_info_set_listen_tech_mask_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-set-listen-tech-mask",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_test_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_test_method_info_sim_test,
+  &_net_nfc_gdbus_test_method_info_prbs_test,
+  &_net_nfc_gdbus_test_method_info_get_firmware_version,
+  &_net_nfc_gdbus_test_method_info_set_ee_data,
+  &_net_nfc_gdbus_test_method_info_ese_test,
+  &_net_nfc_gdbus_test_method_info_set_se_tech_type,
+  &_net_nfc_gdbus_test_method_info_set_listen_tech_mask,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_test_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Test",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_test_method_info_pointers,
+    NULL,
+    NULL,
+    NULL
+  },
+  "test",
+};
+
+
+/**
+ * net_nfc_gdbus_test_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_test_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_test_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusTest interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_test_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusTest:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link>.
+ */
+
+/**
+ * NetNfcGDbusTestIface:
+ * @parent_iface: The parent interface.
+ * @handle_ese_test: Handler for the #NetNfcGDbusTest::handle-ese-test signal.
+ * @handle_get_firmware_version: Handler for the #NetNfcGDbusTest::handle-get-firmware-version signal.
+ * @handle_prbs_test: Handler for the #NetNfcGDbusTest::handle-prbs-test signal.
+ * @handle_set_ee_data: Handler for the #NetNfcGDbusTest::handle-set-ee-data signal.
+ * @handle_set_listen_tech_mask: Handler for the #NetNfcGDbusTest::handle-set-listen-tech-mask signal.
+ * @handle_set_se_tech_type: Handler for the #NetNfcGDbusTest::handle-set-se-tech-type signal.
+ * @handle_sim_test: Handler for the #NetNfcGDbusTest::handle-sim-test signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link>.
+ */
+
+typedef NetNfcGDbusTestIface NetNfcGDbusTestInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusTest, net_nfc_gdbus_test, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_test_default_init (NetNfcGDbusTestIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusTest::handle-sim-test:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SimTest">SimTest()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_sim_test() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-sim-test",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_sim_test),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTest::handle-prbs-test:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_tech: Argument passed by remote caller.
+   * @arg_rate: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.PrbsTest">PrbsTest()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_prbs_test() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-prbs-test",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_prbs_test),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusTest::handle-get-firmware-version:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.GetFirmwareVersion">GetFirmwareVersion()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_get_firmware_version() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-get-firmware-version",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_get_firmware_version),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTest::handle-set-ee-data:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_mode: Argument passed by remote caller.
+   * @arg_reg_id: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetEeData">SetEeData()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_set_ee_data() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-ee-data",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_set_ee_data),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusTest::handle-ese-test:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.EseTest">EseTest()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_ese_test() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-ese-test",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_ese_test),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusTest::handle-set-se-tech-type:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_tech: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetSeTechType">SetSeTechType()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_set_se_tech_type() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-se-tech-type",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_set_se_tech_type),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusTest::handle-set-listen-tech-mask:
+   * @object: A #NetNfcGDbusTest.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_tech: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetListenTechMask">SetListenTechMask()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_test_complete_set_listen_tech_mask() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-set-listen-tech-mask",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusTestIface, handle_set_listen_tech_mask),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    2,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT);
+
+}
+
+/**
+ * net_nfc_gdbus_test_call_sim_test:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SimTest">SimTest()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_sim_test_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_sim_test_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_sim_test (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SimTest",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_sim_test_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_sim_test().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_sim_test().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_sim_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_sim_test_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SimTest">SimTest()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_sim_test() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_sim_test_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SimTest",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_prbs_test:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @arg_rate: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.PrbsTest">PrbsTest()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_prbs_test_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_prbs_test_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_prbs_test (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    guint arg_rate,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "PrbsTest",
+    g_variant_new ("(uu)",
+                   arg_tech,
+                   arg_rate),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_prbs_test_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_prbs_test().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_prbs_test().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_prbs_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_prbs_test_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @arg_rate: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.PrbsTest">PrbsTest()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_prbs_test() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_prbs_test_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    guint arg_rate,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "PrbsTest",
+    g_variant_new ("(uu)",
+                   arg_tech,
+                   arg_rate),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_get_firmware_version:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.GetFirmwareVersion">GetFirmwareVersion()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_get_firmware_version_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_get_firmware_version_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_get_firmware_version (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "GetFirmwareVersion",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_get_firmware_version_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_version: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_get_firmware_version().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_get_firmware_version().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_get_firmware_version_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    gchar **out_version,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(is)",
+                 out_result,
+                 out_version);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_get_firmware_version_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_version: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.GetFirmwareVersion">GetFirmwareVersion()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_get_firmware_version() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_get_firmware_version_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    gchar **out_version,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "GetFirmwareVersion",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(is)",
+                 out_result,
+                 out_version);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_ee_data:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @arg_reg_id: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetEeData">SetEeData()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_set_ee_data_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_set_ee_data_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_set_ee_data (
+    NetNfcGDbusTest *proxy,
+    guint arg_mode,
+    guint arg_reg_id,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetEeData",
+    g_variant_new ("(uu@a(y))",
+                   arg_mode,
+                   arg_reg_id,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_ee_data_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_set_ee_data().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_set_ee_data().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_ee_data_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_ee_data_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_mode: Argument to pass with the method invocation.
+ * @arg_reg_id: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetEeData">SetEeData()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_set_ee_data() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_ee_data_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_mode,
+    guint arg_reg_id,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetEeData",
+    g_variant_new ("(uu@a(y))",
+                   arg_mode,
+                   arg_reg_id,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_ese_test:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.EseTest">EseTest()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_ese_test_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_ese_test_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_ese_test (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "EseTest",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_ese_test_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_ese_test().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_ese_test().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_ese_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_ese_test_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.EseTest">EseTest()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_ese_test() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_ese_test_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "EseTest",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_se_tech_type:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetSeTechType">SetSeTechType()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_set_se_tech_type_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_set_se_tech_type_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_set_se_tech_type (
+    NetNfcGDbusTest *proxy,
+    guint arg_type,
+    guint arg_tech,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetSeTechType",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_tech),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_se_tech_type_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_set_se_tech_type().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_set_se_tech_type().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_se_tech_type_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_se_tech_type_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetSeTechType">SetSeTechType()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_set_se_tech_type() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_se_tech_type_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_type,
+    guint arg_tech,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetSeTechType",
+    g_variant_new ("(uu)",
+                   arg_type,
+                   arg_tech),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_listen_tech_mask:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetListenTechMask">SetListenTechMask()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_call_set_listen_tech_mask_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_call_set_listen_tech_mask_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_test_call_set_listen_tech_mask (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "SetListenTechMask",
+    g_variant_new ("(u)",
+                   arg_tech),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_listen_tech_mask_finish:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_call_set_listen_tech_mask().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_call_set_listen_tech_mask().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_listen_tech_mask_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_call_set_listen_tech_mask_sync:
+ * @proxy: A #NetNfcGDbusTestProxy.
+ * @arg_tech: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetListenTechMask">SetListenTechMask()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_call_set_listen_tech_mask() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_test_call_set_listen_tech_mask_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "SetListenTechMask",
+    g_variant_new ("(u)",
+                   arg_tech),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_complete_sim_test:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SimTest">SimTest()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_sim_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_prbs_test:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.PrbsTest">PrbsTest()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_prbs_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_get_firmware_version:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @version: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.GetFirmwareVersion">GetFirmwareVersion()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_get_firmware_version (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    const gchar *version)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(is)",
+                   result,
+                   version));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_set_ee_data:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetEeData">SetEeData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_set_ee_data (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_ese_test:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.EseTest">EseTest()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_ese_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_set_se_tech_type:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetSeTechType">SetSeTechType()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_set_se_tech_type (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_test_complete_set_listen_tech_mask:
+ * @object: A #NetNfcGDbusTest.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Test.SetListenTechMask">SetListenTechMask()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_test_complete_set_listen_tech_mask (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTestProxy:
+ *
+ * The #NetNfcGDbusTestProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTestProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTestProxy.
+ */
+
+struct _NetNfcGDbusTestProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_test_proxy_iface_init (NetNfcGDbusTestIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTestProxy, net_nfc_gdbus_test_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusTestProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TEST, net_nfc_gdbus_test_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTestProxy, net_nfc_gdbus_test_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TEST, net_nfc_gdbus_test_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_test_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusTestProxy *proxy = NET_NFC_GDBUS_TEST_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_test_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_test_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_test_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_test_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_TEST);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TEST);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_test_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusTestProxy *proxy = NET_NFC_GDBUS_TEST_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_test_proxy_init (NetNfcGDbusTestProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_test_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_TEST_PROXY, NetNfcGDbusTestProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_test_interface_info ());
+}
+
+static void
+net_nfc_gdbus_test_proxy_class_init (NetNfcGDbusTestProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_test_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_test_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_test_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_test_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_test_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTestProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_test_proxy_iface_init (NetNfcGDbusTestIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_test_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_test_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TEST_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Test", NULL);
+}
+
+/**
+ * net_nfc_gdbus_test_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTestProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTest *
+net_nfc_gdbus_test_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TEST (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTestProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTest *
+net_nfc_gdbus_test_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TEST_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Test", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TEST (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_test_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_test_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_test_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_test_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_test_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_TEST_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Test", NULL);
+}
+
+/**
+ * net_nfc_gdbus_test_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_test_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_test_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTestProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTest *
+net_nfc_gdbus_test_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TEST (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_test_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_test_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_test_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTestProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusTest *
+net_nfc_gdbus_test_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_TEST_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Test", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_TEST (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusTestSkeleton:
+ *
+ * The #NetNfcGDbusTestSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusTestSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusTestSkeleton.
+ */
+
+struct _NetNfcGDbusTestSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_test_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusTestSkeleton *skeleton = NET_NFC_GDBUS_TEST_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_TEST);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_TEST);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_test_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTestSkeleton *skeleton = NET_NFC_GDBUS_TEST_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_test_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusTestSkeleton *skeleton = NET_NFC_GDBUS_TEST_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_test_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_test_skeleton_vtable =
+{
+  _net_nfc_gdbus_test_skeleton_handle_method_call,
+  _net_nfc_gdbus_test_skeleton_handle_get_property,
+  _net_nfc_gdbus_test_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_test_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_test_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_test_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_test_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_test_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusTestSkeleton *skeleton = NET_NFC_GDBUS_TEST_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_test_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_test_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_test_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_test_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Test", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_test_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void net_nfc_gdbus_test_skeleton_iface_init (NetNfcGDbusTestIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTestSkeleton, net_nfc_gdbus_test_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusTestSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TEST, net_nfc_gdbus_test_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusTestSkeleton, net_nfc_gdbus_test_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_TEST, net_nfc_gdbus_test_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_test_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusTestSkeleton *skeleton = NET_NFC_GDBUS_TEST_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_test_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_test_skeleton_init (NetNfcGDbusTestSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_test_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_TEST_SKELETON, NetNfcGDbusTestSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_test_skeleton_class_init (NetNfcGDbusTestSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_test_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_test_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_test_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_test_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_test_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusTestSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_test_skeleton_iface_init (NetNfcGDbusTestIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_test_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Test.top_of_page">org.tizen.NetNfcService.Test</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusTestSkeleton): The skeleton object.
+ */
+NetNfcGDbusTest *
+net_nfc_gdbus_test_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_TEST (g_object_new (NET_NFC_GDBUS_TYPE_TEST_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Snep
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusSnep
+ * @title: NetNfcGDbusSnep
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Snep D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Snep ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_register_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_register_IN_ARG_san =
+{
+  {
+    -1,
+    (gchar *) "san",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_register_IN_ARG_user_data =
+{
+  {
+    -1,
+    (gchar *) "user_data",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_register_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_register_IN_ARG_sap,
+  &_net_nfc_gdbus_snep_method_info_server_register_IN_ARG_san,
+  &_net_nfc_gdbus_snep_method_info_server_register_IN_ARG_user_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_register_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_register_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_register_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_server_register =
+{
+  {
+    -1,
+    (gchar *) "ServerRegister",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_register_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_register_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-server-register",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_san =
+{
+  {
+    -1,
+    (gchar *) "san",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_sap,
+  &_net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_san,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_unregister_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_unregister_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_unregister_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_server_unregister =
+{
+  {
+    -1,
+    (gchar *) "ServerUnregister",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_unregister_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_unregister_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-server-unregister",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_start_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_start_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_start_IN_ARG_san =
+{
+  {
+    -1,
+    (gchar *) "san",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_start_IN_ARG_user_data =
+{
+  {
+    -1,
+    (gchar *) "user_data",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_start_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_start_IN_ARG_handle,
+  &_net_nfc_gdbus_snep_method_info_server_start_IN_ARG_sap,
+  &_net_nfc_gdbus_snep_method_info_server_start_IN_ARG_san,
+  &_net_nfc_gdbus_snep_method_info_server_start_IN_ARG_user_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_server_start_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_server_start_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_start_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_server_start =
+{
+  {
+    -1,
+    (gchar *) "ServerStart",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_start_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_server_start_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-server-start",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_start_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_start_IN_ARG_sap =
+{
+  {
+    -1,
+    (gchar *) "sap",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_start_IN_ARG_san =
+{
+  {
+    -1,
+    (gchar *) "san",
+    (gchar *) "s",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_start_IN_ARG_user_data =
+{
+  {
+    -1,
+    (gchar *) "user_data",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_client_start_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_client_start_IN_ARG_handle,
+  &_net_nfc_gdbus_snep_method_info_client_start_IN_ARG_sap,
+  &_net_nfc_gdbus_snep_method_info_client_start_IN_ARG_san,
+  &_net_nfc_gdbus_snep_method_info_client_start_IN_ARG_user_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_start_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_client_start_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_client_start_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_client_start =
+{
+  {
+    -1,
+    (gchar *) "ClientStart",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_client_start_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_client_start_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-client-start",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_IN_ARG_snep_handle =
+{
+  {
+    -1,
+    (gchar *) "snep_handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_IN_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_IN_ARG_ndef_msg =
+{
+  {
+    -1,
+    (gchar *) "ndef_msg",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_client_request_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_client_request_IN_ARG_snep_handle,
+  &_net_nfc_gdbus_snep_method_info_client_request_IN_ARG_type,
+  &_net_nfc_gdbus_snep_method_info_client_request_IN_ARG_ndef_msg,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_type =
+{
+  {
+    -1,
+    (gchar *) "type",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_result,
+  &_net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_type,
+  &_net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_client_request =
+{
+  {
+    -1,
+    (gchar *) "ClientRequest",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_client_request_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_client_request_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-client-request",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_snep_handle =
+{
+  {
+    -1,
+    (gchar *) "snep_handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_handle,
+  &_net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_snep_handle,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_method_info_stop_snep_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_method_info_stop_snep_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_stop_snep_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_snep_method_info_stop_snep =
+{
+  {
+    -1,
+    (gchar *) "StopSnep",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_stop_snep_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_method_info_stop_snep_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-stop-snep",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_snep_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_snep_method_info_server_register,
+  &_net_nfc_gdbus_snep_method_info_server_unregister,
+  &_net_nfc_gdbus_snep_method_info_server_start,
+  &_net_nfc_gdbus_snep_method_info_client_start,
+  &_net_nfc_gdbus_snep_method_info_client_request,
+  &_net_nfc_gdbus_snep_method_info_stop_snep,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_signal_info_snep_event_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_signal_info_snep_event_ARG_event =
+{
+  {
+    -1,
+    (gchar *) "event",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_signal_info_snep_event_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_signal_info_snep_event_ARG_ndef_msg =
+{
+  {
+    -1,
+    (gchar *) "ndef_msg",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_snep_signal_info_snep_event_ARG_user_data =
+{
+  {
+    -1,
+    (gchar *) "user_data",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_snep_signal_info_snep_event_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_handle,
+  &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_event,
+  &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_result,
+  &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_ndef_msg,
+  &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_user_data,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_snep_signal_info_snep_event =
+{
+  {
+    -1,
+    (gchar *) "SnepEvent",
+    (GDBusArgInfo **) &_net_nfc_gdbus_snep_signal_info_snep_event_ARG_pointers,
+    NULL
+  },
+  "snep-event"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_snep_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_snep_signal_info_snep_event,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_snep_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Snep",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_snep_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_snep_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "snep",
+};
+
+
+/**
+ * net_nfc_gdbus_snep_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_snep_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_snep_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusSnep interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_snep_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusSnep:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link>.
+ */
+
+/**
+ * NetNfcGDbusSnepIface:
+ * @parent_iface: The parent interface.
+ * @handle_client_request: Handler for the #NetNfcGDbusSnep::handle-client-request signal.
+ * @handle_client_start: Handler for the #NetNfcGDbusSnep::handle-client-start signal.
+ * @handle_server_register: Handler for the #NetNfcGDbusSnep::handle-server-register signal.
+ * @handle_server_start: Handler for the #NetNfcGDbusSnep::handle-server-start signal.
+ * @handle_server_unregister: Handler for the #NetNfcGDbusSnep::handle-server-unregister signal.
+ * @handle_stop_snep: Handler for the #NetNfcGDbusSnep::handle-stop-snep signal.
+ * @snep_event: Handler for the #NetNfcGDbusSnep::snep-event signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link>.
+ */
+
+typedef NetNfcGDbusSnepIface NetNfcGDbusSnepInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusSnep, net_nfc_gdbus_snep, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_snep_default_init (NetNfcGDbusSnepIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusSnep::handle-server-register:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_san: Argument passed by remote caller.
+   * @arg_user_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerRegister">ServerRegister()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_server_register() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-server-register",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_server_register),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSnep::handle-server-unregister:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_san: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerUnregister">ServerUnregister()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_server_unregister() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-server-unregister",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_server_unregister),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_STRING);
+
+  /**
+   * NetNfcGDbusSnep::handle-server-start:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_san: Argument passed by remote caller.
+   * @arg_user_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerStart">ServerStart()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_server_start() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-server-start",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_server_start),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    5,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSnep::handle-client-start:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_sap: Argument passed by remote caller.
+   * @arg_san: Argument passed by remote caller.
+   * @arg_user_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientStart">ClientStart()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_client_start() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-client-start",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_client_start),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    5,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT);
+
+  /**
+   * NetNfcGDbusSnep::handle-client-request:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_snep_handle: Argument passed by remote caller.
+   * @arg_type: Argument passed by remote caller.
+   * @arg_ndef_msg: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientRequest">ClientRequest()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_client_request() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-client-request",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_client_request),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    4,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /**
+   * NetNfcGDbusSnep::handle-stop-snep:
+   * @object: A #NetNfcGDbusSnep.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_snep_handle: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.StopSnep">StopSnep()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_snep_complete_stop_snep() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-stop-snep",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, handle_stop_snep),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusSnep::snep-event:
+   * @object: A #NetNfcGDbusSnep.
+   * @arg_handle: Argument.
+   * @arg_event: Argument.
+   * @arg_result: Argument.
+   * @arg_ndef_msg: Argument.
+   * @arg_user_data: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Snep.SnepEvent">"SnepEvent"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("snep-event",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusSnepIface, snep_event),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    5, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT, G_TYPE_VARIANT, G_TYPE_UINT);
+
+}
+
+/**
+ * net_nfc_gdbus_snep_emit_snep_event:
+ * @object: A #NetNfcGDbusSnep.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_event: Argument to pass with the signal.
+ * @arg_result: Argument to pass with the signal.
+ * @arg_ndef_msg: Argument to pass with the signal.
+ * @arg_user_data: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Snep.SnepEvent">"SnepEvent"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_snep_emit_snep_event (
+    NetNfcGDbusSnep *object,
+    guint arg_handle,
+    guint arg_event,
+    gint arg_result,
+    GVariant *arg_ndef_msg,
+    guint arg_user_data)
+{
+  g_signal_emit_by_name (object, "snep-event", arg_handle, arg_event, arg_result, arg_ndef_msg, arg_user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_register:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerRegister">ServerRegister()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_server_register_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_server_register_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_server_register (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ServerRegister",
+    g_variant_new ("(usu)",
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_register_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_server_register().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_server_register().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_register_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_register_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerRegister">ServerRegister()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_server_register() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_register_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ServerRegister",
+    g_variant_new ("(usu)",
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_unregister:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerUnregister">ServerUnregister()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_server_unregister_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_server_unregister_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_server_unregister (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ServerUnregister",
+    g_variant_new ("(us)",
+                   arg_sap,
+                   arg_san),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_unregister_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_server_unregister().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_server_unregister().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_unregister_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_unregister_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerUnregister">ServerUnregister()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_server_unregister() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_unregister_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ServerUnregister",
+    g_variant_new ("(us)",
+                   arg_sap,
+                   arg_san),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_start:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerStart">ServerStart()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_server_start_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_server_start_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_server_start (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ServerStart",
+    g_variant_new ("(uusu)",
+                   arg_handle,
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_start_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_server_start().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_server_start().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_start_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_server_start_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerStart">ServerStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_server_start() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_server_start_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ServerStart",
+    g_variant_new ("(uusu)",
+                   arg_handle,
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_start:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientStart">ClientStart()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_client_start_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_client_start_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_client_start (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ClientStart",
+    g_variant_new ("(uusu)",
+                   arg_handle,
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_start_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_client_start().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_client_start().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_client_start_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_start_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_sap: Argument to pass with the method invocation.
+ * @arg_san: Argument to pass with the method invocation.
+ * @arg_user_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientStart">ClientStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_client_start() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_client_start_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ClientStart",
+    g_variant_new ("(uusu)",
+                   arg_handle,
+                   arg_sap,
+                   arg_san,
+                   arg_user_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_request:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_snep_handle: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_ndef_msg: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientRequest">ClientRequest()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_client_request_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_client_request_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_client_request (
+    NetNfcGDbusSnep *proxy,
+    guint arg_snep_handle,
+    guint arg_type,
+    GVariant *arg_ndef_msg,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ClientRequest",
+    g_variant_new ("(uu@a(y))",
+                   arg_snep_handle,
+                   arg_type,
+                   arg_ndef_msg),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_request_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_client_request().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_client_request().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_client_request_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    guint *out_type,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu@a(y))",
+                 out_result,
+                 out_type,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_client_request_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_snep_handle: Argument to pass with the method invocation.
+ * @arg_type: Argument to pass with the method invocation.
+ * @arg_ndef_msg: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @out_type: (out): Return location for return parameter or %NULL to ignore.
+ * @out_data: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientRequest">ClientRequest()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_client_request() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_client_request_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_snep_handle,
+    guint arg_type,
+    GVariant *arg_ndef_msg,
+    gint *out_result,
+    guint *out_type,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ClientRequest",
+    g_variant_new ("(uu@a(y))",
+                   arg_snep_handle,
+                   arg_type,
+                   arg_ndef_msg),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(iu@a(y))",
+                 out_result,
+                 out_type,
+                 out_data);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_stop_snep:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_snep_handle: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.StopSnep">StopSnep()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_call_stop_snep_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_call_stop_snep_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_snep_call_stop_snep (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_snep_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "StopSnep",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_snep_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_snep_call_stop_snep_finish:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_call_stop_snep().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_call_stop_snep().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_stop_snep_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_call_stop_snep_sync:
+ * @proxy: A #NetNfcGDbusSnepProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_snep_handle: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.StopSnep">StopSnep()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_call_stop_snep() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_snep_call_stop_snep_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_snep_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "StopSnep",
+    g_variant_new ("(uu)",
+                   arg_handle,
+                   arg_snep_handle),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_server_register:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerRegister">ServerRegister()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_server_register (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_server_unregister:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerUnregister">ServerUnregister()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_server_unregister (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_server_start:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ServerStart">ServerStart()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_server_start (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_client_start:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientStart">ClientStart()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_client_start (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_client_request:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ * @type: Parameter to return.
+ * @data: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.ClientRequest">ClientRequest()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_client_request (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint type,
+    GVariant *data)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(iu@a(y))",
+                   result,
+                   type,
+                   data));
+}
+
+/**
+ * net_nfc_gdbus_snep_complete_stop_snep:
+ * @object: A #NetNfcGDbusSnep.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Snep.StopSnep">StopSnep()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_snep_complete_stop_snep (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusSnepProxy:
+ *
+ * The #NetNfcGDbusSnepProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusSnepProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusSnepProxy.
+ */
+
+struct _NetNfcGDbusSnepProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_snep_proxy_iface_init (NetNfcGDbusSnepIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSnepProxy, net_nfc_gdbus_snep_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusSnepProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SNEP, net_nfc_gdbus_snep_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSnepProxy, net_nfc_gdbus_snep_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SNEP, net_nfc_gdbus_snep_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_snep_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusSnepProxy *proxy = NET_NFC_GDBUS_SNEP_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_snep_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_snep_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_snep_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_snep_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_SNEP);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_SNEP);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_snep_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusSnepProxy *proxy = NET_NFC_GDBUS_SNEP_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_snep_proxy_init (NetNfcGDbusSnepProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_snep_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_SNEP_PROXY, NetNfcGDbusSnepProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_snep_interface_info ());
+}
+
+static void
+net_nfc_gdbus_snep_proxy_class_init (NetNfcGDbusSnepProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_snep_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_snep_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_snep_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_snep_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_snep_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusSnepProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_snep_proxy_iface_init (NetNfcGDbusSnepIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_snep_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_snep_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_SNEP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Snep", NULL);
+}
+
+/**
+ * net_nfc_gdbus_snep_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSnepProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSnep *
+net_nfc_gdbus_snep_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SNEP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSnepProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSnep *
+net_nfc_gdbus_snep_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_SNEP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Snep", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SNEP (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_snep_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_snep_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_snep_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_snep_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_snep_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_SNEP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Snep", NULL);
+}
+
+/**
+ * net_nfc_gdbus_snep_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_snep_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_snep_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSnepProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSnep *
+net_nfc_gdbus_snep_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SNEP (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_snep_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_snep_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_snep_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSnepProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusSnep *
+net_nfc_gdbus_snep_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_SNEP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Snep", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_SNEP (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusSnepSkeleton:
+ *
+ * The #NetNfcGDbusSnepSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusSnepSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusSnepSkeleton.
+ */
+
+struct _NetNfcGDbusSnepSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_snep_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_SNEP);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_SNEP);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_snep_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_snep_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_snep_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_snep_skeleton_vtable =
+{
+  _net_nfc_gdbus_snep_skeleton_handle_method_call,
+  _net_nfc_gdbus_snep_skeleton_handle_get_property,
+  _net_nfc_gdbus_snep_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_snep_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_snep_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_snep_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_snep_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_snep_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_snep_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_snep_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_snep_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_snep_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Snep", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_snep_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_snep_on_signal_snep_event (
+    NetNfcGDbusSnep *object,
+    guint arg_handle,
+    guint arg_event,
+    gint arg_result,
+    GVariant *arg_ndef_msg,
+    guint arg_user_data)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(uui@a(y)u)",
+                   arg_handle,
+                   arg_event,
+                   arg_result,
+                   arg_ndef_msg,
+                   arg_user_data));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Snep", "SnepEvent",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_snep_skeleton_iface_init (NetNfcGDbusSnepIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSnepSkeleton, net_nfc_gdbus_snep_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusSnepSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SNEP, net_nfc_gdbus_snep_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusSnepSkeleton, net_nfc_gdbus_snep_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_SNEP, net_nfc_gdbus_snep_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_snep_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusSnepSkeleton *skeleton = NET_NFC_GDBUS_SNEP_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_snep_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_snep_skeleton_init (NetNfcGDbusSnepSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_snep_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_SNEP_SKELETON, NetNfcGDbusSnepSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_snep_skeleton_class_init (NetNfcGDbusSnepSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_snep_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_snep_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_snep_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_snep_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_snep_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusSnepSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_snep_skeleton_iface_init (NetNfcGDbusSnepIface *iface)
+{
+  iface->snep_event = _net_nfc_gdbus_snep_on_signal_snep_event;
+}
+
+/**
+ * net_nfc_gdbus_snep_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Snep.top_of_page">org.tizen.NetNfcService.Snep</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusSnepSkeleton): The skeleton object.
+ */
+NetNfcGDbusSnep *
+net_nfc_gdbus_snep_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_SNEP (g_object_new (NET_NFC_GDBUS_TYPE_SNEP_SKELETON, NULL));
+}
+
+/* ------------------------------------------------------------------------
+ * Code for interface org.tizen.NetNfcService.Hce
+ * ------------------------------------------------------------------------
+ */
+
+/**
+ * SECTION:NetNfcGDbusHce
+ * @title: NetNfcGDbusHce
+ * @short_description: Generated C code for the org.tizen.NetNfcService.Hce D-Bus interface
+ *
+ * This section contains code for working with the <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link> D-Bus interface in C.
+ */
+
+/* ---- Introspection data for org.tizen.NetNfcService.Hce ---- */
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_method_info_start_hce_handler_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_hce_method_info_start_hce_handler_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_hce_method_info_start_hce_handler_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_hce_method_info_start_hce_handler =
+{
+  {
+    -1,
+    (gchar *) "StartHceHandler",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_hce_method_info_start_hce_handler_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-start-hce-handler",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_method_info_stop_hce_handler_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_hce_method_info_stop_hce_handler_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_hce_method_info_stop_hce_handler_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_hce_method_info_stop_hce_handler =
+{
+  {
+    -1,
+    (gchar *) "StopHceHandler",
+    NULL,
+    (GDBusArgInfo **) &_net_nfc_gdbus_hce_method_info_stop_hce_handler_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-stop-hce-handler",
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_data =
+{
+  {
+    -1,
+    (gchar *) "data",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_handle,
+  &_net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_data,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_method_info_response_apdu_OUT_ARG_result =
+{
+  {
+    -1,
+    (gchar *) "result",
+    (gchar *) "i",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_hce_method_info_response_apdu_OUT_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_hce_method_info_response_apdu_OUT_ARG_result,
+  NULL
+};
+
+static const _ExtendedGDBusMethodInfo _net_nfc_gdbus_hce_method_info_response_apdu =
+{
+  {
+    -1,
+    (gchar *) "ResponseApdu",
+    (GDBusArgInfo **) &_net_nfc_gdbus_hce_method_info_response_apdu_IN_ARG_pointers,
+    (GDBusArgInfo **) &_net_nfc_gdbus_hce_method_info_response_apdu_OUT_ARG_pointers,
+    NULL
+  },
+  "handle-response-apdu",
+  FALSE
+};
+
+static const _ExtendedGDBusMethodInfo * const _net_nfc_gdbus_hce_method_info_pointers[] =
+{
+  &_net_nfc_gdbus_hce_method_info_start_hce_handler,
+  &_net_nfc_gdbus_hce_method_info_stop_hce_handler,
+  &_net_nfc_gdbus_hce_method_info_response_apdu,
+  NULL
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_signal_info_event_received_ARG_handle =
+{
+  {
+    -1,
+    (gchar *) "handle",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_signal_info_event_received_ARG_event =
+{
+  {
+    -1,
+    (gchar *) "event",
+    (gchar *) "u",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo _net_nfc_gdbus_hce_signal_info_event_received_ARG_apdu =
+{
+  {
+    -1,
+    (gchar *) "apdu",
+    (gchar *) "a(y)",
+    NULL
+  },
+  FALSE
+};
+
+static const _ExtendedGDBusArgInfo * const _net_nfc_gdbus_hce_signal_info_event_received_ARG_pointers[] =
+{
+  &_net_nfc_gdbus_hce_signal_info_event_received_ARG_handle,
+  &_net_nfc_gdbus_hce_signal_info_event_received_ARG_event,
+  &_net_nfc_gdbus_hce_signal_info_event_received_ARG_apdu,
+  NULL
+};
+
+static const _ExtendedGDBusSignalInfo _net_nfc_gdbus_hce_signal_info_event_received =
+{
+  {
+    -1,
+    (gchar *) "EventReceived",
+    (GDBusArgInfo **) &_net_nfc_gdbus_hce_signal_info_event_received_ARG_pointers,
+    NULL
+  },
+  "event-received"
+};
+
+static const _ExtendedGDBusSignalInfo * const _net_nfc_gdbus_hce_signal_info_pointers[] =
+{
+  &_net_nfc_gdbus_hce_signal_info_event_received,
+  NULL
+};
+
+static const _ExtendedGDBusInterfaceInfo _net_nfc_gdbus_hce_interface_info =
+{
+  {
+    -1,
+    (gchar *) "org.tizen.NetNfcService.Hce",
+    (GDBusMethodInfo **) &_net_nfc_gdbus_hce_method_info_pointers,
+    (GDBusSignalInfo **) &_net_nfc_gdbus_hce_signal_info_pointers,
+    NULL,
+    NULL
+  },
+  "hce",
+};
+
+
+/**
+ * net_nfc_gdbus_hce_interface_info:
+ *
+ * Gets a machine-readable description of the <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link> D-Bus interface.
+ *
+ * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
+ */
+GDBusInterfaceInfo *
+net_nfc_gdbus_hce_interface_info (void)
+{
+  return (GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct;
+}
+
+/**
+ * net_nfc_gdbus_hce_override_properties:
+ * @klass: The class structure for a #GObject derived class.
+ * @property_id_begin: The property id to assign to the first overridden property.
+ *
+ * Overrides all #GObject properties in the #NetNfcGDbusHce interface for a concrete class.
+ * The properties are overridden in the order they are defined.
+ *
+ * Returns: The last property id.
+ */
+guint
+net_nfc_gdbus_hce_override_properties (GObjectClass *klass, guint property_id_begin)
+{
+  return property_id_begin - 1;
+}
+
+
+
+/**
+ * NetNfcGDbusHce:
+ *
+ * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link>.
+ */
+
+/**
+ * NetNfcGDbusHceIface:
+ * @parent_iface: The parent interface.
+ * @handle_response_apdu: Handler for the #NetNfcGDbusHce::handle-response-apdu signal.
+ * @handle_start_hce_handler: Handler for the #NetNfcGDbusHce::handle-start-hce-handler signal.
+ * @handle_stop_hce_handler: Handler for the #NetNfcGDbusHce::handle-stop-hce-handler signal.
+ * @event_received: Handler for the #NetNfcGDbusHce::event-received signal.
+ *
+ * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link>.
+ */
+
+typedef NetNfcGDbusHceIface NetNfcGDbusHceInterface;
+G_DEFINE_INTERFACE (NetNfcGDbusHce, net_nfc_gdbus_hce, G_TYPE_OBJECT)
+
+static void
+net_nfc_gdbus_hce_default_init (NetNfcGDbusHceIface *iface)
+{
+  /* GObject signals for incoming D-Bus method calls: */
+  /**
+   * NetNfcGDbusHce::handle-start-hce-handler:
+   * @object: A #NetNfcGDbusHce.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StartHceHandler">StartHceHandler()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_hce_complete_start_hce_handler() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-start-hce-handler",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHceIface, handle_start_hce_handler),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusHce::handle-stop-hce-handler:
+   * @object: A #NetNfcGDbusHce.
+   * @invocation: A #GDBusMethodInvocation.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StopHceHandler">StopHceHandler()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_hce_complete_stop_hce_handler() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-stop-hce-handler",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHceIface, handle_stop_hce_handler),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    1,
+    G_TYPE_DBUS_METHOD_INVOCATION);
+
+  /**
+   * NetNfcGDbusHce::handle-response-apdu:
+   * @object: A #NetNfcGDbusHce.
+   * @invocation: A #GDBusMethodInvocation.
+   * @arg_handle: Argument passed by remote caller.
+   * @arg_data: Argument passed by remote caller.
+   *
+   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.ResponseApdu">ResponseApdu()</link> D-Bus method.
+   *
+   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call net_nfc_gdbus_hce_complete_response_apdu() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
+   *
+   * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
+   */
+  g_signal_new ("handle-response-apdu",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHceIface, handle_response_apdu),
+    g_signal_accumulator_true_handled,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_BOOLEAN,
+    3,
+    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);
+
+  /* GObject signals for received D-Bus signals: */
+  /**
+   * NetNfcGDbusHce::event-received:
+   * @object: A #NetNfcGDbusHce.
+   * @arg_handle: Argument.
+   * @arg_event: Argument.
+   * @arg_apdu: Argument.
+   *
+   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-tizen-NetNfcService-Hce.EventReceived">"EventReceived"</link> is received.
+   *
+   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
+   */
+  g_signal_new ("event-received",
+    G_TYPE_FROM_INTERFACE (iface),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (NetNfcGDbusHceIface, event_received),
+    NULL,
+    NULL,
+    g_cclosure_marshal_generic,
+    G_TYPE_NONE,
+    3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_VARIANT);
+
+}
+
+/**
+ * net_nfc_gdbus_hce_emit_event_received:
+ * @object: A #NetNfcGDbusHce.
+ * @arg_handle: Argument to pass with the signal.
+ * @arg_event: Argument to pass with the signal.
+ * @arg_apdu: Argument to pass with the signal.
+ *
+ * Emits the <link linkend="gdbus-signal-org-tizen-NetNfcService-Hce.EventReceived">"EventReceived"</link> D-Bus signal.
+ */
+void
+net_nfc_gdbus_hce_emit_event_received (
+    NetNfcGDbusHce *object,
+    guint arg_handle,
+    guint arg_event,
+    GVariant *arg_apdu)
+{
+  g_signal_emit_by_name (object, "event-received", arg_handle, arg_event, arg_apdu);
+}
+
+/**
+ * net_nfc_gdbus_hce_call_start_hce_handler:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StartHceHandler">StartHceHandler()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_hce_call_start_hce_handler_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_hce_call_start_hce_handler_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_hce_call_start_hce_handler (
+    NetNfcGDbusHce *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "StartHceHandler",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_hce_call_start_hce_handler_finish:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_hce_call_start_hce_handler().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_hce_call_start_hce_handler().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_start_hce_handler_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_call_start_hce_handler_sync:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StartHceHandler">StartHceHandler()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_hce_call_start_hce_handler() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_start_hce_handler_sync (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "StartHceHandler",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_call_stop_hce_handler:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StopHceHandler">StopHceHandler()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_hce_call_stop_hce_handler_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_hce_call_stop_hce_handler_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_hce_call_stop_hce_handler (
+    NetNfcGDbusHce *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "StopHceHandler",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_hce_call_stop_hce_handler_finish:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_hce_call_stop_hce_handler().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_hce_call_stop_hce_handler().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_stop_hce_handler_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_call_stop_hce_handler_sync:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StopHceHandler">StopHceHandler()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_hce_call_stop_hce_handler() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_stop_hce_handler_sync (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "StopHceHandler",
+    g_variant_new ("()"),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_call_response_apdu:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.ResponseApdu">ResponseApdu()</link> D-Bus method on @proxy.
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_hce_call_response_apdu_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_hce_call_response_apdu_sync() for the synchronous, blocking version of this method.
+ */
+void
+net_nfc_gdbus_hce_call_response_apdu (
+    NetNfcGDbusHce *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data)
+{
+  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
+    "ResponseApdu",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    callback,
+    user_data);
+}
+
+/**
+ * net_nfc_gdbus_hce_call_response_apdu_finish:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_hce_call_response_apdu().
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with net_nfc_gdbus_hce_call_response_apdu().
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_response_apdu_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_call_response_apdu_sync:
+ * @proxy: A #NetNfcGDbusHceProxy.
+ * @arg_handle: Argument to pass with the method invocation.
+ * @arg_data: Argument to pass with the method invocation.
+ * @out_result: (out): Return location for return parameter or %NULL to ignore.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously invokes the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.ResponseApdu">ResponseApdu()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_hce_call_response_apdu() for the asynchronous version of this method.
+ *
+ * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
+ */
+gboolean
+net_nfc_gdbus_hce_call_response_apdu_sync (
+    NetNfcGDbusHce *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error)
+{
+  GVariant *_ret;
+  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
+    "ResponseApdu",
+    g_variant_new ("(u@a(y))",
+                   arg_handle,
+                   arg_data),
+    G_DBUS_CALL_FLAGS_NONE,
+    -1,
+    cancellable,
+    error);
+  if (_ret == NULL)
+    goto _out;
+  g_variant_get (_ret,
+                 "(i)",
+                 out_result);
+  g_variant_unref (_ret);
+_out:
+  return _ret != NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_complete_start_hce_handler:
+ * @object: A #NetNfcGDbusHce.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StartHceHandler">StartHceHandler()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_hce_complete_start_hce_handler (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_hce_complete_stop_hce_handler:
+ * @object: A #NetNfcGDbusHce.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.StopHceHandler">StopHceHandler()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_hce_complete_stop_hce_handler (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/**
+ * net_nfc_gdbus_hce_complete_response_apdu:
+ * @object: A #NetNfcGDbusHce.
+ * @invocation: (transfer full): A #GDBusMethodInvocation.
+ * @result: Parameter to return.
+ *
+ * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-tizen-NetNfcService-Hce.ResponseApdu">ResponseApdu()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
+ *
+ * This method will free @invocation, you cannot use it afterwards.
+ */
+void
+net_nfc_gdbus_hce_complete_response_apdu (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result)
+{
+  g_dbus_method_invocation_return_value (invocation,
+    g_variant_new ("(i)",
+                   result));
+}
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusHceProxy:
+ *
+ * The #NetNfcGDbusHceProxy structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusHceProxyClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusHceProxy.
+ */
+
+struct _NetNfcGDbusHceProxyPrivate
+{
+  GData *qdata;
+};
+
+static void net_nfc_gdbus_hce_proxy_iface_init (NetNfcGDbusHceIface *iface);
+
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHceProxy, net_nfc_gdbus_hce_proxy, G_TYPE_DBUS_PROXY,
+                         G_ADD_PRIVATE (NetNfcGDbusHceProxy)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HCE, net_nfc_gdbus_hce_proxy_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHceProxy, net_nfc_gdbus_hce_proxy, G_TYPE_DBUS_PROXY,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HCE, net_nfc_gdbus_hce_proxy_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_hce_proxy_finalize (GObject *object)
+{
+  NetNfcGDbusHceProxy *proxy = NET_NFC_GDBUS_HCE_PROXY (object);
+  g_datalist_clear (&proxy->priv->qdata);
+  G_OBJECT_CLASS (net_nfc_gdbus_hce_proxy_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_hce_proxy_get_property (GObject      *object,
+  guint         prop_id,
+  GValue       *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_hce_proxy_set_property (GObject      *object,
+  guint         prop_id,
+  const GValue *value,
+  GParamSpec   *pspec G_GNUC_UNUSED)
+{
+}
+
+static void
+net_nfc_gdbus_hce_proxy_g_signal (GDBusProxy *proxy,
+  const gchar *sender_name G_GNUC_UNUSED,
+  const gchar *signal_name,
+  GVariant *parameters)
+{
+  _ExtendedGDBusSignalInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  gsize n;
+  guint signal_id;
+  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct, signal_name);
+  if (info == NULL)
+    return;
+  num_params = g_variant_n_children (parameters);
+  paramv = g_new0 (GValue, num_params + 1);
+  g_value_init (&paramv[0], NET_NFC_GDBUS_TYPE_HCE);
+  g_value_set_object (&paramv[0], proxy);
+  g_variant_iter_init (&iter, parameters);
+  n = 1;
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_HCE);
+  g_signal_emitv (paramv, signal_id, 0, NULL);
+  for (n = 0; n < num_params + 1; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static void
+net_nfc_gdbus_hce_proxy_g_properties_changed (GDBusProxy *_proxy,
+  GVariant *changed_properties,
+  const gchar *const *invalidated_properties)
+{
+  NetNfcGDbusHceProxy *proxy = NET_NFC_GDBUS_HCE_PROXY (_proxy);
+  guint n;
+  const gchar *key;
+  GVariantIter *iter;
+  _ExtendedGDBusPropertyInfo *info;
+  g_variant_get (changed_properties, "a{sv}", &iter);
+  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct, key);
+      g_datalist_remove_data (&proxy->priv->qdata, key);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+  g_variant_iter_free (iter);
+  for (n = 0; invalidated_properties[n] != NULL; n++)
+    {
+      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct, invalidated_properties[n]);
+      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
+      if (info != NULL)
+        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
+    }
+}
+
+static void
+net_nfc_gdbus_hce_proxy_init (NetNfcGDbusHceProxy *proxy)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  proxy->priv = net_nfc_gdbus_hce_proxy_get_instance_private (proxy);
+#else
+  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, NET_NFC_GDBUS_TYPE_HCE_PROXY, NetNfcGDbusHceProxyPrivate);
+#endif
+
+  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), net_nfc_gdbus_hce_interface_info ());
+}
+
+static void
+net_nfc_gdbus_hce_proxy_class_init (NetNfcGDbusHceProxyClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusProxyClass *proxy_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize     = net_nfc_gdbus_hce_proxy_finalize;
+  gobject_class->get_property = net_nfc_gdbus_hce_proxy_get_property;
+  gobject_class->set_property = net_nfc_gdbus_hce_proxy_set_property;
+
+  proxy_class = G_DBUS_PROXY_CLASS (klass);
+  proxy_class->g_signal = net_nfc_gdbus_hce_proxy_g_signal;
+  proxy_class->g_properties_changed = net_nfc_gdbus_hce_proxy_g_properties_changed;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusHceProxyPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_hce_proxy_iface_init (NetNfcGDbusHceIface *iface)
+{
+}
+
+/**
+ * net_nfc_gdbus_hce_proxy_new:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link>. See g_dbus_proxy_new() for more details.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_hce_proxy_new_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_hce_proxy_new_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_hce_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_HCE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Hce", NULL);
+}
+
+/**
+ * net_nfc_gdbus_hce_proxy_new_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_hce_proxy_new().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_hce_proxy_new().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHceProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HCE (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_proxy_new_sync:
+ * @connection: A #GDBusConnection.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link>. See g_dbus_proxy_new_sync() for more details.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_hce_proxy_new() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHceProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_HCE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Hce", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HCE (ret);
+  else
+    return NULL;
+}
+
+
+/**
+ * net_nfc_gdbus_hce_proxy_new_for_bus:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: User data to pass to @callback.
+ *
+ * Like net_nfc_gdbus_hce_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
+ * You can then call net_nfc_gdbus_hce_proxy_new_for_bus_finish() to get the result of the operation.
+ *
+ * See net_nfc_gdbus_hce_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
+ */
+void
+net_nfc_gdbus_hce_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data)
+{
+  g_async_initable_new_async (NET_NFC_GDBUS_TYPE_HCE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Hce", NULL);
+}
+
+/**
+ * net_nfc_gdbus_hce_proxy_new_for_bus_finish:
+ * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to net_nfc_gdbus_hce_proxy_new_for_bus().
+ * @error: Return location for error or %NULL
+ *
+ * Finishes an operation started with net_nfc_gdbus_hce_proxy_new_for_bus().
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHceProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error)
+{
+  GObject *ret;
+  GObject *source_object;
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HCE (ret);
+  else
+    return NULL;
+}
+
+/**
+ * net_nfc_gdbus_hce_proxy_new_for_bus_sync:
+ * @bus_type: A #GBusType.
+ * @flags: Flags from the #GDBusProxyFlags enumeration.
+ * @name: A bus name (well-known or unique).
+ * @object_path: An object path.
+ * @cancellable: (nullable): A #GCancellable or %NULL.
+ * @error: Return location for error or %NULL
+ *
+ * Like net_nfc_gdbus_hce_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+ *
+ * The calling thread is blocked until a reply is received.
+ *
+ * See net_nfc_gdbus_hce_proxy_new_for_bus() for the asynchronous version of this constructor.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHceProxy): The constructed proxy object or %NULL if @error is set.
+ */
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error)
+{
+  GInitable *ret;
+  ret = g_initable_new (NET_NFC_GDBUS_TYPE_HCE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.tizen.NetNfcService.Hce", NULL);
+  if (ret != NULL)
+    return NET_NFC_GDBUS_HCE (ret);
+  else
+    return NULL;
+}
+
+
+/* ------------------------------------------------------------------------ */
+
+/**
+ * NetNfcGDbusHceSkeleton:
+ *
+ * The #NetNfcGDbusHceSkeleton structure contains only private data and should only be accessed using the provided API.
+ */
+
+/**
+ * NetNfcGDbusHceSkeletonClass:
+ * @parent_class: The parent class.
+ *
+ * Class structure for #NetNfcGDbusHceSkeleton.
+ */
+
+struct _NetNfcGDbusHceSkeletonPrivate
+{
+  GValue *properties;
+  GList *changed_properties;
+  GSource *changed_properties_idle_source;
+  GMainContext *context;
+  GMutex lock;
+};
+
+static void
+_net_nfc_gdbus_hce_skeleton_handle_method_call (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name,
+  const gchar *method_name,
+  GVariant *parameters,
+  GDBusMethodInvocation *invocation,
+  gpointer user_data)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (user_data);
+  _ExtendedGDBusMethodInfo *info;
+  GVariantIter iter;
+  GVariant *child;
+  GValue *paramv;
+  gsize num_params;
+  guint num_extra;
+  gsize n;
+  guint signal_id;
+  GValue return_value = G_VALUE_INIT;
+  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
+  g_assert (info != NULL);
+  num_params = g_variant_n_children (parameters);
+  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
+  n = 0;
+  g_value_init (&paramv[n], NET_NFC_GDBUS_TYPE_HCE);
+  g_value_set_object (&paramv[n++], skeleton);
+  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
+  g_value_set_object (&paramv[n++], invocation);
+  if (info->pass_fdlist)
+    {
+#ifdef G_OS_UNIX
+      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
+      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
+#else
+      g_assert_not_reached ();
+#endif
+    }
+  g_variant_iter_init (&iter, parameters);
+  while ((child = g_variant_iter_next_value (&iter)) != NULL)
+    {
+      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
+      if (arg_info->use_gvariant)
+        {
+          g_value_init (&paramv[n], G_TYPE_VARIANT);
+          g_value_set_variant (&paramv[n], child);
+          n++;
+        }
+      else
+        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
+      g_variant_unref (child);
+    }
+  signal_id = g_signal_lookup (info->signal_name, NET_NFC_GDBUS_TYPE_HCE);
+  g_value_init (&return_value, G_TYPE_BOOLEAN);
+  g_signal_emitv (paramv, signal_id, 0, &return_value);
+  if (!g_value_get_boolean (&return_value))
+    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
+  g_value_unset (&return_value);
+  for (n = 0; n < num_params + num_extra; n++)
+    g_value_unset (&paramv[n]);
+  g_free (paramv);
+}
+
+static GVariant *
+_net_nfc_gdbus_hce_skeleton_handle_get_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  GVariant *ret;
+  ret = NULL;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      g_value_init (&value, pspec->value_type);
+      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
+      g_value_unset (&value);
+    }
+  return ret;
+}
+
+static gboolean
+_net_nfc_gdbus_hce_skeleton_handle_set_property (
+  GDBusConnection *connection G_GNUC_UNUSED,
+  const gchar *sender G_GNUC_UNUSED,
+  const gchar *object_path G_GNUC_UNUSED,
+  const gchar *interface_name G_GNUC_UNUSED,
+  const gchar *property_name,
+  GVariant *variant,
+  GError **error,
+  gpointer user_data)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (user_data);
+  GValue value = G_VALUE_INIT;
+  GParamSpec *pspec;
+  _ExtendedGDBusPropertyInfo *info;
+  gboolean ret;
+  ret = FALSE;
+  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_net_nfc_gdbus_hce_interface_info.parent_struct, property_name);
+  g_assert (info != NULL);
+  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
+  if (pspec == NULL)
+    {
+      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
+    }
+  else
+    {
+      if (info->use_gvariant)
+        g_value_set_variant (&value, variant);
+      else
+        g_dbus_gvariant_to_gvalue (variant, &value);
+      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
+      g_value_unset (&value);
+      ret = TRUE;
+    }
+  return ret;
+}
+
+static const GDBusInterfaceVTable _net_nfc_gdbus_hce_skeleton_vtable =
+{
+  _net_nfc_gdbus_hce_skeleton_handle_method_call,
+  _net_nfc_gdbus_hce_skeleton_handle_get_property,
+  _net_nfc_gdbus_hce_skeleton_handle_set_property,
+  {NULL}
+};
+
+static GDBusInterfaceInfo *
+net_nfc_gdbus_hce_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return net_nfc_gdbus_hce_interface_info ();
+}
+
+static GDBusInterfaceVTable *
+net_nfc_gdbus_hce_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
+{
+  return (GDBusInterfaceVTable *) &_net_nfc_gdbus_hce_skeleton_vtable;
+}
+
+static GVariant *
+net_nfc_gdbus_hce_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (_skeleton);
+
+  GVariantBuilder builder;
+  guint n;
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
+  if (_net_nfc_gdbus_hce_interface_info.parent_struct.properties == NULL)
+    goto out;
+  for (n = 0; _net_nfc_gdbus_hce_interface_info.parent_struct.properties[n] != NULL; n++)
+    {
+      GDBusPropertyInfo *info = _net_nfc_gdbus_hce_interface_info.parent_struct.properties[n];
+      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
+        {
+          GVariant *value;
+          value = _net_nfc_gdbus_hce_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Hce", info->name, NULL, skeleton);
+          if (value != NULL)
+            {
+              g_variant_take_ref (value);
+              g_variant_builder_add (&builder, "{sv}", info->name, value);
+              g_variant_unref (value);
+            }
+        }
+    }
+out:
+  return g_variant_builder_end (&builder);
+}
+
+static void
+net_nfc_gdbus_hce_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
+{
+}
+
+static void
+_net_nfc_gdbus_hce_on_signal_event_received (
+    NetNfcGDbusHce *object,
+    guint arg_handle,
+    guint arg_event,
+    GVariant *arg_apdu)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (object);
+
+  GList      *connections, *l;
+  GVariant   *signal_variant;
+  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
+
+  signal_variant = g_variant_ref_sink (g_variant_new ("(uu@a(y))",
+                   arg_handle,
+                   arg_event,
+                   arg_apdu));
+  for (l = connections; l != NULL; l = l->next)
+    {
+      GDBusConnection *connection = l->data;
+      g_dbus_connection_emit_signal (connection,
+        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.tizen.NetNfcService.Hce", "EventReceived",
+        signal_variant, NULL);
+    }
+  g_variant_unref (signal_variant);
+  g_list_free_full (connections, g_object_unref);
+}
+
+static void net_nfc_gdbus_hce_skeleton_iface_init (NetNfcGDbusHceIface *iface);
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHceSkeleton, net_nfc_gdbus_hce_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_ADD_PRIVATE (NetNfcGDbusHceSkeleton)
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HCE, net_nfc_gdbus_hce_skeleton_iface_init))
+
+#else
+G_DEFINE_TYPE_WITH_CODE (NetNfcGDbusHceSkeleton, net_nfc_gdbus_hce_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
+                         G_IMPLEMENT_INTERFACE (NET_NFC_GDBUS_TYPE_HCE, net_nfc_gdbus_hce_skeleton_iface_init))
+
+#endif
+static void
+net_nfc_gdbus_hce_skeleton_finalize (GObject *object)
+{
+  NetNfcGDbusHceSkeleton *skeleton = NET_NFC_GDBUS_HCE_SKELETON (object);
+  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
+  if (skeleton->priv->changed_properties_idle_source != NULL)
+    g_source_destroy (skeleton->priv->changed_properties_idle_source);
+  g_main_context_unref (skeleton->priv->context);
+  g_mutex_clear (&skeleton->priv->lock);
+  G_OBJECT_CLASS (net_nfc_gdbus_hce_skeleton_parent_class)->finalize (object);
+}
+
+static void
+net_nfc_gdbus_hce_skeleton_init (NetNfcGDbusHceSkeleton *skeleton)
+{
+#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
+  skeleton->priv = net_nfc_gdbus_hce_skeleton_get_instance_private (skeleton);
+#else
+  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, NET_NFC_GDBUS_TYPE_HCE_SKELETON, NetNfcGDbusHceSkeletonPrivate);
+#endif
+
+  g_mutex_init (&skeleton->priv->lock);
+  skeleton->priv->context = g_main_context_ref_thread_default ();
+}
+
+static void
+net_nfc_gdbus_hce_skeleton_class_init (NetNfcGDbusHceSkeletonClass *klass)
+{
+  GObjectClass *gobject_class;
+  GDBusInterfaceSkeletonClass *skeleton_class;
+
+  gobject_class = G_OBJECT_CLASS (klass);
+  gobject_class->finalize = net_nfc_gdbus_hce_skeleton_finalize;
+
+  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
+  skeleton_class->get_info = net_nfc_gdbus_hce_skeleton_dbus_interface_get_info;
+  skeleton_class->get_properties = net_nfc_gdbus_hce_skeleton_dbus_interface_get_properties;
+  skeleton_class->flush = net_nfc_gdbus_hce_skeleton_dbus_interface_flush;
+  skeleton_class->get_vtable = net_nfc_gdbus_hce_skeleton_dbus_interface_get_vtable;
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
+  g_type_class_add_private (klass, sizeof (NetNfcGDbusHceSkeletonPrivate));
+#endif
+}
+
+static void
+net_nfc_gdbus_hce_skeleton_iface_init (NetNfcGDbusHceIface *iface)
+{
+  iface->event_received = _net_nfc_gdbus_hce_on_signal_event_received;
+}
+
+/**
+ * net_nfc_gdbus_hce_skeleton_new:
+ *
+ * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-tizen-NetNfcService-Hce.top_of_page">org.tizen.NetNfcService.Hce</link>.
+ *
+ * Returns: (transfer full) (type NetNfcGDbusHceSkeleton): The skeleton object.
+ */
+NetNfcGDbusHce *
+net_nfc_gdbus_hce_skeleton_new (void)
+{
+  return NET_NFC_GDBUS_HCE (g_object_new (NET_NFC_GDBUS_TYPE_HCE_SKELETON, NULL));
+}
+
diff --git a/unittest/net_nfc_gdbus.h b/unittest/net_nfc_gdbus.h
new file mode 100755 (executable)
index 0000000..8515417
--- /dev/null
@@ -0,0 +1,4243 @@
+/*
+ * Generated by gdbus-codegen 2.56.4. DO NOT EDIT.
+ *
+ * The license of this code is the same as for the D-Bus interface description
+ * it was derived from.
+ */
+
+#ifndef __NET_NFC_GDBUS_H__
+#define __NET_NFC_GDBUS_H__
+
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Manager */
+
+#define NET_NFC_GDBUS_TYPE_MANAGER (net_nfc_gdbus_manager_get_type ())
+#define NET_NFC_GDBUS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_MANAGER, NetNfcGDbusManager))
+#define NET_NFC_GDBUS_IS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_MANAGER))
+#define NET_NFC_GDBUS_MANAGER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_MANAGER, NetNfcGDbusManagerIface))
+
+struct _NetNfcGDbusManager;
+typedef struct _NetNfcGDbusManager NetNfcGDbusManager;
+typedef struct _NetNfcGDbusManagerIface NetNfcGDbusManagerIface;
+
+struct _NetNfcGDbusManagerIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_configure_discovery) (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_mode);
+
+  gboolean (*handle_get_server_state) (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_set_active) (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gboolean arg_is_active);
+
+  void (*activated) (
+    NetNfcGDbusManager *object,
+    gboolean arg_active);
+
+};
+
+GType net_nfc_gdbus_manager_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_manager_interface_info (void);
+guint net_nfc_gdbus_manager_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_manager_complete_set_active (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_manager_complete_get_server_state (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint state);
+
+void net_nfc_gdbus_manager_complete_configure_discovery (
+    NetNfcGDbusManager *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_manager_emit_activated (
+    NetNfcGDbusManager *object,
+    gboolean arg_active);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_manager_call_set_active (
+    NetNfcGDbusManager *proxy,
+    gboolean arg_is_active,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_manager_call_set_active_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_manager_call_set_active_sync (
+    NetNfcGDbusManager *proxy,
+    gboolean arg_is_active,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_manager_call_get_server_state (
+    NetNfcGDbusManager *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_manager_call_get_server_state_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    guint *out_state,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_manager_call_get_server_state_sync (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    guint *out_state,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_manager_call_configure_discovery (
+    NetNfcGDbusManager *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_manager_call_configure_discovery_finish (
+    NetNfcGDbusManager *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_manager_call_configure_discovery_sync (
+    NetNfcGDbusManager *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_MANAGER_PROXY (net_nfc_gdbus_manager_proxy_get_type ())
+#define NET_NFC_GDBUS_MANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_MANAGER_PROXY, NetNfcGDbusManagerProxy))
+#define NET_NFC_GDBUS_MANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_MANAGER_PROXY, NetNfcGDbusManagerProxyClass))
+#define NET_NFC_GDBUS_MANAGER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_MANAGER_PROXY, NetNfcGDbusManagerProxyClass))
+#define NET_NFC_GDBUS_IS_MANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_MANAGER_PROXY))
+#define NET_NFC_GDBUS_IS_MANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_MANAGER_PROXY))
+
+typedef struct _NetNfcGDbusManagerProxy NetNfcGDbusManagerProxy;
+typedef struct _NetNfcGDbusManagerProxyClass NetNfcGDbusManagerProxyClass;
+typedef struct _NetNfcGDbusManagerProxyPrivate NetNfcGDbusManagerProxyPrivate;
+
+struct _NetNfcGDbusManagerProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusManagerProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusManagerProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_manager_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusManagerProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_manager_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusManager *net_nfc_gdbus_manager_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusManager *net_nfc_gdbus_manager_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_manager_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusManager *net_nfc_gdbus_manager_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusManager *net_nfc_gdbus_manager_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_MANAGER_SKELETON (net_nfc_gdbus_manager_skeleton_get_type ())
+#define NET_NFC_GDBUS_MANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_MANAGER_SKELETON, NetNfcGDbusManagerSkeleton))
+#define NET_NFC_GDBUS_MANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_MANAGER_SKELETON, NetNfcGDbusManagerSkeletonClass))
+#define NET_NFC_GDBUS_MANAGER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_MANAGER_SKELETON, NetNfcGDbusManagerSkeletonClass))
+#define NET_NFC_GDBUS_IS_MANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_MANAGER_SKELETON))
+#define NET_NFC_GDBUS_IS_MANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_MANAGER_SKELETON))
+
+typedef struct _NetNfcGDbusManagerSkeleton NetNfcGDbusManagerSkeleton;
+typedef struct _NetNfcGDbusManagerSkeletonClass NetNfcGDbusManagerSkeletonClass;
+typedef struct _NetNfcGDbusManagerSkeletonPrivate NetNfcGDbusManagerSkeletonPrivate;
+
+struct _NetNfcGDbusManagerSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusManagerSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusManagerSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_manager_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusManagerSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusManager *net_nfc_gdbus_manager_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Tag */
+
+#define NET_NFC_GDBUS_TYPE_TAG (net_nfc_gdbus_tag_get_type ())
+#define NET_NFC_GDBUS_TAG(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TAG, NetNfcGDbusTag))
+#define NET_NFC_GDBUS_IS_TAG(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TAG))
+#define NET_NFC_GDBUS_TAG_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_TAG, NetNfcGDbusTagIface))
+
+struct _NetNfcGDbusTag;
+typedef struct _NetNfcGDbusTag NetNfcGDbusTag;
+typedef struct _NetNfcGDbusTagIface NetNfcGDbusTagIface;
+
+struct _NetNfcGDbusTagIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_get_barcode) (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_get_current_tag_info) (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_get_current_target_handle) (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_is_tag_connected) (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation);
+
+  void (*tag_detached) (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type);
+
+  void (*tag_discovered) (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type,
+    gboolean arg_is_ndef_supported,
+    guchar arg_ndef_card_state,
+    guint arg_max_data_size,
+    guint arg_actual_data_size,
+    guint arg_number_of_keys,
+    GVariant *arg_target_info_values,
+    GVariant *arg_raw_data);
+
+};
+
+GType net_nfc_gdbus_tag_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_tag_interface_info (void);
+guint net_nfc_gdbus_tag_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_tag_complete_is_tag_connected (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    gint dev_type);
+
+void net_nfc_gdbus_tag_complete_get_current_tag_info (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    guint handle,
+    gint dev_type,
+    gboolean is_ndef_supported,
+    guchar ndef_card_state,
+    guint max_data_size,
+    guint actual_data_size,
+    guint number_of_keys,
+    GVariant *target_info_values,
+    GVariant *raw_data);
+
+void net_nfc_gdbus_tag_complete_get_barcode (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *barcode);
+
+void net_nfc_gdbus_tag_complete_get_current_target_handle (
+    NetNfcGDbusTag *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean is_connected,
+    guint handle,
+    gint dev_type);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_tag_emit_tag_discovered (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type,
+    gboolean arg_is_ndef_supported,
+    guchar arg_ndef_card_state,
+    guint arg_max_data_size,
+    guint arg_actual_data_size,
+    guint arg_number_of_keys,
+    GVariant *arg_target_info_values,
+    GVariant *arg_raw_data);
+
+void net_nfc_gdbus_tag_emit_tag_detached (
+    NetNfcGDbusTag *object,
+    guint arg_handle,
+    gint arg_dev_type);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_tag_call_is_tag_connected (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_tag_call_is_tag_connected_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    gint *out_dev_type,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_tag_call_is_tag_connected_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    gint *out_dev_type,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_tag_call_get_current_tag_info (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_tag_call_get_current_tag_info_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    gboolean *out_is_ndef_supported,
+    guchar *out_ndef_card_state,
+    guint *out_max_data_size,
+    guint *out_actual_data_size,
+    guint *out_number_of_keys,
+    GVariant **out_target_info_values,
+    GVariant **out_raw_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_tag_call_get_current_tag_info_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    gboolean *out_is_ndef_supported,
+    guchar *out_ndef_card_state,
+    guint *out_max_data_size,
+    guint *out_actual_data_size,
+    guint *out_number_of_keys,
+    GVariant **out_target_info_values,
+    GVariant **out_raw_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_tag_call_get_barcode (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_tag_call_get_barcode_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    GVariant **out_barcode,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_tag_call_get_barcode_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    GVariant **out_barcode,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_tag_call_get_current_target_handle (
+    NetNfcGDbusTag *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_tag_call_get_current_target_handle_finish (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_tag_call_get_current_target_handle_sync (
+    NetNfcGDbusTag *proxy,
+    gint *out_result,
+    gboolean *out_is_connected,
+    guint *out_handle,
+    gint *out_dev_type,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TAG_PROXY (net_nfc_gdbus_tag_proxy_get_type ())
+#define NET_NFC_GDBUS_TAG_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TAG_PROXY, NetNfcGDbusTagProxy))
+#define NET_NFC_GDBUS_TAG_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TAG_PROXY, NetNfcGDbusTagProxyClass))
+#define NET_NFC_GDBUS_TAG_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TAG_PROXY, NetNfcGDbusTagProxyClass))
+#define NET_NFC_GDBUS_IS_TAG_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TAG_PROXY))
+#define NET_NFC_GDBUS_IS_TAG_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TAG_PROXY))
+
+typedef struct _NetNfcGDbusTagProxy NetNfcGDbusTagProxy;
+typedef struct _NetNfcGDbusTagProxyClass NetNfcGDbusTagProxyClass;
+typedef struct _NetNfcGDbusTagProxyPrivate NetNfcGDbusTagProxyPrivate;
+
+struct _NetNfcGDbusTagProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusTagProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusTagProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_tag_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTagProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_tag_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTag *net_nfc_gdbus_tag_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTag *net_nfc_gdbus_tag_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_tag_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTag *net_nfc_gdbus_tag_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTag *net_nfc_gdbus_tag_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TAG_SKELETON (net_nfc_gdbus_tag_skeleton_get_type ())
+#define NET_NFC_GDBUS_TAG_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TAG_SKELETON, NetNfcGDbusTagSkeleton))
+#define NET_NFC_GDBUS_TAG_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TAG_SKELETON, NetNfcGDbusTagSkeletonClass))
+#define NET_NFC_GDBUS_TAG_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TAG_SKELETON, NetNfcGDbusTagSkeletonClass))
+#define NET_NFC_GDBUS_IS_TAG_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TAG_SKELETON))
+#define NET_NFC_GDBUS_IS_TAG_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TAG_SKELETON))
+
+typedef struct _NetNfcGDbusTagSkeleton NetNfcGDbusTagSkeleton;
+typedef struct _NetNfcGDbusTagSkeletonClass NetNfcGDbusTagSkeletonClass;
+typedef struct _NetNfcGDbusTagSkeletonPrivate NetNfcGDbusTagSkeletonPrivate;
+
+struct _NetNfcGDbusTagSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusTagSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusTagSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_tag_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTagSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusTag *net_nfc_gdbus_tag_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Ndef */
+
+#define NET_NFC_GDBUS_TYPE_NDEF (net_nfc_gdbus_ndef_get_type ())
+#define NET_NFC_GDBUS_NDEF(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_NDEF, NetNfcGDbusNdef))
+#define NET_NFC_GDBUS_IS_NDEF(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_NDEF))
+#define NET_NFC_GDBUS_NDEF_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_NDEF, NetNfcGDbusNdefIface))
+
+struct _NetNfcGDbusNdef;
+typedef struct _NetNfcGDbusNdef NetNfcGDbusNdef;
+typedef struct _NetNfcGDbusNdefIface NetNfcGDbusNdefIface;
+
+struct _NetNfcGDbusNdefIface
+{
+  GTypeInterface parent_iface;
+
+  gboolean (*handle_format) (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    GVariant *arg_key);
+
+  gboolean (*handle_make_read_only) (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle);
+
+  gboolean (*handle_read) (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle);
+
+  gboolean (*handle_write) (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    GVariant *arg_data);
+
+};
+
+GType net_nfc_gdbus_ndef_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_ndef_interface_info (void);
+guint net_nfc_gdbus_ndef_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_ndef_complete_read (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *data);
+
+void net_nfc_gdbus_ndef_complete_write (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_ndef_complete_make_read_only (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_ndef_complete_format (
+    NetNfcGDbusNdef *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_ndef_call_read (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_ndef_call_read_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_ndef_call_read_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_ndef_call_write (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_ndef_call_write_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_ndef_call_write_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_ndef_call_make_read_only (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_ndef_call_make_read_only_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_ndef_call_make_read_only_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_ndef_call_format (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_key,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_ndef_call_format_finish (
+    NetNfcGDbusNdef *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_ndef_call_format_sync (
+    NetNfcGDbusNdef *proxy,
+    guint arg_handle,
+    GVariant *arg_key,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_NDEF_PROXY (net_nfc_gdbus_ndef_proxy_get_type ())
+#define NET_NFC_GDBUS_NDEF_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_NDEF_PROXY, NetNfcGDbusNdefProxy))
+#define NET_NFC_GDBUS_NDEF_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_NDEF_PROXY, NetNfcGDbusNdefProxyClass))
+#define NET_NFC_GDBUS_NDEF_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_NDEF_PROXY, NetNfcGDbusNdefProxyClass))
+#define NET_NFC_GDBUS_IS_NDEF_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_NDEF_PROXY))
+#define NET_NFC_GDBUS_IS_NDEF_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_NDEF_PROXY))
+
+typedef struct _NetNfcGDbusNdefProxy NetNfcGDbusNdefProxy;
+typedef struct _NetNfcGDbusNdefProxyClass NetNfcGDbusNdefProxyClass;
+typedef struct _NetNfcGDbusNdefProxyPrivate NetNfcGDbusNdefProxyPrivate;
+
+struct _NetNfcGDbusNdefProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusNdefProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusNdefProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_ndef_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusNdefProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_ndef_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusNdef *net_nfc_gdbus_ndef_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusNdef *net_nfc_gdbus_ndef_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_ndef_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusNdef *net_nfc_gdbus_ndef_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusNdef *net_nfc_gdbus_ndef_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_NDEF_SKELETON (net_nfc_gdbus_ndef_skeleton_get_type ())
+#define NET_NFC_GDBUS_NDEF_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_NDEF_SKELETON, NetNfcGDbusNdefSkeleton))
+#define NET_NFC_GDBUS_NDEF_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_NDEF_SKELETON, NetNfcGDbusNdefSkeletonClass))
+#define NET_NFC_GDBUS_NDEF_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_NDEF_SKELETON, NetNfcGDbusNdefSkeletonClass))
+#define NET_NFC_GDBUS_IS_NDEF_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_NDEF_SKELETON))
+#define NET_NFC_GDBUS_IS_NDEF_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_NDEF_SKELETON))
+
+typedef struct _NetNfcGDbusNdefSkeleton NetNfcGDbusNdefSkeleton;
+typedef struct _NetNfcGDbusNdefSkeletonClass NetNfcGDbusNdefSkeletonClass;
+typedef struct _NetNfcGDbusNdefSkeletonPrivate NetNfcGDbusNdefSkeletonPrivate;
+
+struct _NetNfcGDbusNdefSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusNdefSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusNdefSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_ndef_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusNdefSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusNdef *net_nfc_gdbus_ndef_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Llcp */
+
+#define NET_NFC_GDBUS_TYPE_LLCP (net_nfc_gdbus_llcp_get_type ())
+#define NET_NFC_GDBUS_LLCP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_LLCP, NetNfcGDbusLlcp))
+#define NET_NFC_GDBUS_IS_LLCP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_LLCP))
+#define NET_NFC_GDBUS_LLCP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_LLCP, NetNfcGDbusLlcpIface))
+
+struct _NetNfcGDbusLlcp;
+typedef struct _NetNfcGDbusLlcp NetNfcGDbusLlcp;
+typedef struct _NetNfcGDbusLlcpIface NetNfcGDbusLlcpIface;
+
+struct _NetNfcGDbusLlcpIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_accept) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket);
+
+  gboolean (*handle_close) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket);
+
+  gboolean (*handle_config) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    GVariant *arg_config);
+
+  gboolean (*handle_connect) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    const gchar *arg_service_name);
+
+  gboolean (*handle_connect_sap) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap);
+
+  gboolean (*handle_disconnect) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket);
+
+  gboolean (*handle_listen) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    const gchar *arg_service_name);
+
+  gboolean (*handle_receive) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length);
+
+  gboolean (*handle_receive_from) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length);
+
+  gboolean (*handle_reject) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket);
+
+  gboolean (*handle_send) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    GVariant *arg_data);
+
+  gboolean (*handle_send_to) (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_client_socket,
+    guchar arg_sap,
+    GVariant *arg_data);
+
+  void (*error) (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint arg_error);
+
+  void (*incoming) (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_incoming_socket);
+
+};
+
+GType net_nfc_gdbus_llcp_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_llcp_interface_info (void);
+guint net_nfc_gdbus_llcp_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_llcp_complete_config (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_llcp_complete_listen (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_accept (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_llcp_complete_reject (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_llcp_complete_connect (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_connect_sap (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_send (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_send_to (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_receive (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *data);
+
+void net_nfc_gdbus_llcp_complete_receive_from (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guchar sap,
+    GVariant *data);
+
+void net_nfc_gdbus_llcp_complete_close (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+void net_nfc_gdbus_llcp_complete_disconnect (
+    NetNfcGDbusLlcp *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint client_socket);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_llcp_emit_error (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint arg_error);
+
+void net_nfc_gdbus_llcp_emit_incoming (
+    NetNfcGDbusLlcp *object,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_incoming_socket);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_llcp_call_config (
+    NetNfcGDbusLlcp *proxy,
+    GVariant *arg_config,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_config_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_config_sync (
+    NetNfcGDbusLlcp *proxy,
+    GVariant *arg_config,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_listen (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    const gchar *arg_service_name,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_listen_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_listen_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    const gchar *arg_service_name,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_accept (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_accept_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_accept_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_reject (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_reject_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_reject_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_connect (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    const gchar *arg_service_name,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_connect_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_connect_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    const gchar *arg_service_name,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_connect_sap (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_connect_sap_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_connect_sap_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint16 arg_miu,
+    guchar arg_rw,
+    gint arg_type,
+    guchar arg_sap,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_send (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_send_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_send_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GVariant *arg_data,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_send_to (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guchar arg_sap,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_send_to_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_send_to_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guchar arg_sap,
+    GVariant *arg_data,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_receive (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_receive_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_receive_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    gint *out_result,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_receive_from (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_receive_from_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guchar *out_sap,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_receive_from_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    guint arg_request_length,
+    gint *out_result,
+    guchar *out_sap,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_close (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_close_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_close_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_llcp_call_disconnect (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_llcp_call_disconnect_finish (
+    NetNfcGDbusLlcp *proxy,
+    gint *out_result,
+    guint *out_client_socket,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_llcp_call_disconnect_sync (
+    NetNfcGDbusLlcp *proxy,
+    guint arg_handle,
+    guint arg_client_socket,
+    gint *out_result,
+    guint *out_client_socket,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_LLCP_PROXY (net_nfc_gdbus_llcp_proxy_get_type ())
+#define NET_NFC_GDBUS_LLCP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_LLCP_PROXY, NetNfcGDbusLlcpProxy))
+#define NET_NFC_GDBUS_LLCP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_LLCP_PROXY, NetNfcGDbusLlcpProxyClass))
+#define NET_NFC_GDBUS_LLCP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_LLCP_PROXY, NetNfcGDbusLlcpProxyClass))
+#define NET_NFC_GDBUS_IS_LLCP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_LLCP_PROXY))
+#define NET_NFC_GDBUS_IS_LLCP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_LLCP_PROXY))
+
+typedef struct _NetNfcGDbusLlcpProxy NetNfcGDbusLlcpProxy;
+typedef struct _NetNfcGDbusLlcpProxyClass NetNfcGDbusLlcpProxyClass;
+typedef struct _NetNfcGDbusLlcpProxyPrivate NetNfcGDbusLlcpProxyPrivate;
+
+struct _NetNfcGDbusLlcpProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusLlcpProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusLlcpProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_llcp_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusLlcpProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_llcp_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusLlcp *net_nfc_gdbus_llcp_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusLlcp *net_nfc_gdbus_llcp_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_llcp_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusLlcp *net_nfc_gdbus_llcp_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusLlcp *net_nfc_gdbus_llcp_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_LLCP_SKELETON (net_nfc_gdbus_llcp_skeleton_get_type ())
+#define NET_NFC_GDBUS_LLCP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_LLCP_SKELETON, NetNfcGDbusLlcpSkeleton))
+#define NET_NFC_GDBUS_LLCP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_LLCP_SKELETON, NetNfcGDbusLlcpSkeletonClass))
+#define NET_NFC_GDBUS_LLCP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_LLCP_SKELETON, NetNfcGDbusLlcpSkeletonClass))
+#define NET_NFC_GDBUS_IS_LLCP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_LLCP_SKELETON))
+#define NET_NFC_GDBUS_IS_LLCP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_LLCP_SKELETON))
+
+typedef struct _NetNfcGDbusLlcpSkeleton NetNfcGDbusLlcpSkeleton;
+typedef struct _NetNfcGDbusLlcpSkeletonClass NetNfcGDbusLlcpSkeletonClass;
+typedef struct _NetNfcGDbusLlcpSkeletonPrivate NetNfcGDbusLlcpSkeletonPrivate;
+
+struct _NetNfcGDbusLlcpSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusLlcpSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusLlcpSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_llcp_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusLlcpSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusLlcp *net_nfc_gdbus_llcp_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.P2p */
+
+#define NET_NFC_GDBUS_TYPE_P2P (net_nfc_gdbus_p2p_get_type ())
+#define NET_NFC_GDBUS_P2P(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_P2P, NetNfcGDbusP2p))
+#define NET_NFC_GDBUS_IS_P2P(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_P2P))
+#define NET_NFC_GDBUS_P2P_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_P2P, NetNfcGDbusP2pIface))
+
+struct _NetNfcGDbusP2p;
+typedef struct _NetNfcGDbusP2p NetNfcGDbusP2p;
+typedef struct _NetNfcGDbusP2pIface NetNfcGDbusP2pIface;
+
+struct _NetNfcGDbusP2pIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_send) (
+    NetNfcGDbusP2p *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_type,
+    GVariant *arg_data,
+    guint arg_handle);
+
+  void (*detached) (
+    NetNfcGDbusP2p *object);
+
+  void (*discovered) (
+    NetNfcGDbusP2p *object,
+    guint arg_handle);
+
+  void (*received) (
+    NetNfcGDbusP2p *object,
+    GVariant *arg_data);
+
+};
+
+GType net_nfc_gdbus_p2p_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_p2p_interface_info (void);
+guint net_nfc_gdbus_p2p_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_p2p_complete_send (
+    NetNfcGDbusP2p *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_p2p_emit_detached (
+    NetNfcGDbusP2p *object);
+
+void net_nfc_gdbus_p2p_emit_discovered (
+    NetNfcGDbusP2p *object,
+    guint arg_handle);
+
+void net_nfc_gdbus_p2p_emit_received (
+    NetNfcGDbusP2p *object,
+    GVariant *arg_data);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_p2p_call_send (
+    NetNfcGDbusP2p *proxy,
+    gint arg_type,
+    GVariant *arg_data,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_p2p_call_send_finish (
+    NetNfcGDbusP2p *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_p2p_call_send_sync (
+    NetNfcGDbusP2p *proxy,
+    gint arg_type,
+    GVariant *arg_data,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_P2P_PROXY (net_nfc_gdbus_p2p_proxy_get_type ())
+#define NET_NFC_GDBUS_P2P_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_P2P_PROXY, NetNfcGDbusP2pProxy))
+#define NET_NFC_GDBUS_P2P_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_P2P_PROXY, NetNfcGDbusP2pProxyClass))
+#define NET_NFC_GDBUS_P2P_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_P2P_PROXY, NetNfcGDbusP2pProxyClass))
+#define NET_NFC_GDBUS_IS_P2P_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_P2P_PROXY))
+#define NET_NFC_GDBUS_IS_P2P_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_P2P_PROXY))
+
+typedef struct _NetNfcGDbusP2pProxy NetNfcGDbusP2pProxy;
+typedef struct _NetNfcGDbusP2pProxyClass NetNfcGDbusP2pProxyClass;
+typedef struct _NetNfcGDbusP2pProxyPrivate NetNfcGDbusP2pProxyPrivate;
+
+struct _NetNfcGDbusP2pProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusP2pProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusP2pProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_p2p_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusP2pProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_p2p_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusP2p *net_nfc_gdbus_p2p_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusP2p *net_nfc_gdbus_p2p_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_p2p_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusP2p *net_nfc_gdbus_p2p_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusP2p *net_nfc_gdbus_p2p_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_P2P_SKELETON (net_nfc_gdbus_p2p_skeleton_get_type ())
+#define NET_NFC_GDBUS_P2P_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_P2P_SKELETON, NetNfcGDbusP2pSkeleton))
+#define NET_NFC_GDBUS_P2P_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_P2P_SKELETON, NetNfcGDbusP2pSkeletonClass))
+#define NET_NFC_GDBUS_P2P_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_P2P_SKELETON, NetNfcGDbusP2pSkeletonClass))
+#define NET_NFC_GDBUS_IS_P2P_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_P2P_SKELETON))
+#define NET_NFC_GDBUS_IS_P2P_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_P2P_SKELETON))
+
+typedef struct _NetNfcGDbusP2pSkeleton NetNfcGDbusP2pSkeleton;
+typedef struct _NetNfcGDbusP2pSkeletonClass NetNfcGDbusP2pSkeletonClass;
+typedef struct _NetNfcGDbusP2pSkeletonPrivate NetNfcGDbusP2pSkeletonPrivate;
+
+struct _NetNfcGDbusP2pSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusP2pSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusP2pSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_p2p_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusP2pSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusP2p *net_nfc_gdbus_p2p_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Popup */
+
+#define NET_NFC_GDBUS_TYPE_POPUP (net_nfc_gdbus_popup_get_type ())
+#define NET_NFC_GDBUS_POPUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_POPUP, NetNfcGDbusPopup))
+#define NET_NFC_GDBUS_IS_POPUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_POPUP))
+#define NET_NFC_GDBUS_POPUP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_POPUP, NetNfcGDbusPopupIface))
+
+struct _NetNfcGDbusPopup;
+typedef struct _NetNfcGDbusPopup NetNfcGDbusPopup;
+typedef struct _NetNfcGDbusPopupIface NetNfcGDbusPopupIface;
+
+struct _NetNfcGDbusPopupIface
+{
+  GTypeInterface parent_iface;
+
+  gboolean (*handle_get) (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_set) (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_state,
+    gint arg_focus_state);
+
+};
+
+GType net_nfc_gdbus_popup_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_popup_interface_info (void);
+guint net_nfc_gdbus_popup_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_popup_complete_set (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_popup_complete_get (
+    NetNfcGDbusPopup *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint state);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_popup_call_set (
+    NetNfcGDbusPopup *proxy,
+    gint arg_state,
+    gint arg_focus_state,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_popup_call_set_finish (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_popup_call_set_sync (
+    NetNfcGDbusPopup *proxy,
+    gint arg_state,
+    gint arg_focus_state,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_popup_call_get (
+    NetNfcGDbusPopup *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_popup_call_get_finish (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    gint *out_state,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_popup_call_get_sync (
+    NetNfcGDbusPopup *proxy,
+    gint *out_result,
+    gint *out_state,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_POPUP_PROXY (net_nfc_gdbus_popup_proxy_get_type ())
+#define NET_NFC_GDBUS_POPUP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_POPUP_PROXY, NetNfcGDbusPopupProxy))
+#define NET_NFC_GDBUS_POPUP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_POPUP_PROXY, NetNfcGDbusPopupProxyClass))
+#define NET_NFC_GDBUS_POPUP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_POPUP_PROXY, NetNfcGDbusPopupProxyClass))
+#define NET_NFC_GDBUS_IS_POPUP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_POPUP_PROXY))
+#define NET_NFC_GDBUS_IS_POPUP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_POPUP_PROXY))
+
+typedef struct _NetNfcGDbusPopupProxy NetNfcGDbusPopupProxy;
+typedef struct _NetNfcGDbusPopupProxyClass NetNfcGDbusPopupProxyClass;
+typedef struct _NetNfcGDbusPopupProxyPrivate NetNfcGDbusPopupProxyPrivate;
+
+struct _NetNfcGDbusPopupProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusPopupProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusPopupProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_popup_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusPopupProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_popup_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusPopup *net_nfc_gdbus_popup_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusPopup *net_nfc_gdbus_popup_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_popup_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusPopup *net_nfc_gdbus_popup_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusPopup *net_nfc_gdbus_popup_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_POPUP_SKELETON (net_nfc_gdbus_popup_skeleton_get_type ())
+#define NET_NFC_GDBUS_POPUP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_POPUP_SKELETON, NetNfcGDbusPopupSkeleton))
+#define NET_NFC_GDBUS_POPUP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_POPUP_SKELETON, NetNfcGDbusPopupSkeletonClass))
+#define NET_NFC_GDBUS_POPUP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_POPUP_SKELETON, NetNfcGDbusPopupSkeletonClass))
+#define NET_NFC_GDBUS_IS_POPUP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_POPUP_SKELETON))
+#define NET_NFC_GDBUS_IS_POPUP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_POPUP_SKELETON))
+
+typedef struct _NetNfcGDbusPopupSkeleton NetNfcGDbusPopupSkeleton;
+typedef struct _NetNfcGDbusPopupSkeletonClass NetNfcGDbusPopupSkeletonClass;
+typedef struct _NetNfcGDbusPopupSkeletonPrivate NetNfcGDbusPopupSkeletonPrivate;
+
+struct _NetNfcGDbusPopupSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusPopupSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusPopupSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_popup_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusPopupSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusPopup *net_nfc_gdbus_popup_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.SecureElement */
+
+#define NET_NFC_GDBUS_TYPE_SECURE_ELEMENT (net_nfc_gdbus_secure_element_get_type ())
+#define NET_NFC_GDBUS_SECURE_ELEMENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, NetNfcGDbusSecureElement))
+#define NET_NFC_GDBUS_IS_SECURE_ELEMENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT))
+#define NET_NFC_GDBUS_SECURE_ELEMENT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT, NetNfcGDbusSecureElementIface))
+
+struct _NetNfcGDbusSecureElement;
+typedef struct _NetNfcGDbusSecureElement NetNfcGDbusSecureElement;
+typedef struct _NetNfcGDbusSecureElementIface NetNfcGDbusSecureElementIface;
+
+struct _NetNfcGDbusSecureElementIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_add_route_aid) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    guint arg_se_type,
+    guint arg_category,
+    gboolean arg_unlock,
+    guint arg_power);
+
+  gboolean (*handle_check_transaction_permission) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    GVariant *arg_aid);
+
+  gboolean (*handle_close_secure_element) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle);
+
+  gboolean (*handle_get) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_get_atr) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle);
+
+  gboolean (*handle_get_card_emulation) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_get_conflict_handlers) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    const gchar *arg_package,
+    guint arg_category,
+    const gchar *arg_aid);
+
+  gboolean (*handle_get_handler_storage_info) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_category);
+
+  gboolean (*handle_get_registered_aids) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_category);
+
+  gboolean (*handle_get_registered_handlers) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_category);
+
+  gboolean (*handle_is_activated_aid_handler) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    const gchar *arg_aid);
+
+  gboolean (*handle_is_activated_category_handler) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_category);
+
+  gboolean (*handle_open_secure_element) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_type);
+
+  gboolean (*handle_register_aid) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid);
+
+  gboolean (*handle_remove_package_aids) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    const gchar *arg_package);
+
+  gboolean (*handle_remove_route_aid) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    const gchar *arg_package,
+    const gchar *arg_aid);
+
+  gboolean (*handle_send_apdu) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    GVariant *arg_data);
+
+  gboolean (*handle_set) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_type);
+
+  gboolean (*handle_set_card_emulation) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_mode);
+
+  gboolean (*handle_set_default_route) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_switch_on,
+    guint arg_switch_off,
+    guint arg_battery_off);
+
+  gboolean (*handle_set_preferred_handler) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gboolean arg_state);
+
+  gboolean (*handle_set_transaction_fg_dispatch) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint arg_mode);
+
+  gboolean (*handle_unregister_aid) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid);
+
+  gboolean (*handle_unregister_aids) (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_category);
+
+  void (*card_emulation_mode_changed) (
+    NetNfcGDbusSecureElement *object,
+    gint arg_mode);
+
+  void (*ese_detected) (
+    NetNfcGDbusSecureElement *object,
+    guint arg_handle,
+    gint arg_se_type,
+    GVariant *arg_data);
+
+  void (*rf_detected) (
+    NetNfcGDbusSecureElement *object);
+
+  void (*se_type_changed) (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type);
+
+  void (*transaction_event) (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type,
+    GVariant *arg_aid,
+    GVariant *arg_param,
+    gint arg_fg_dispatch,
+    gint arg_focus_pgid);
+
+};
+
+GType net_nfc_gdbus_secure_element_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_secure_element_interface_info (void);
+guint net_nfc_gdbus_secure_element_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_secure_element_complete_set (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_get (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint type);
+
+void net_nfc_gdbus_secure_element_complete_set_card_emulation (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_get_card_emulation (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint type);
+
+void net_nfc_gdbus_secure_element_complete_open_secure_element (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint handle);
+
+void net_nfc_gdbus_secure_element_complete_close_secure_element (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_get_atr (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *atr);
+
+void net_nfc_gdbus_secure_element_complete_send_apdu (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *response);
+
+void net_nfc_gdbus_secure_element_complete_set_transaction_fg_dispatch (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_set_default_route (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_set_preferred_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_check_transaction_permission (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_is_activated_aid_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean activated);
+
+void net_nfc_gdbus_secure_element_complete_is_activated_category_handler (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gboolean activated);
+
+void net_nfc_gdbus_secure_element_complete_get_registered_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *aids);
+
+void net_nfc_gdbus_secure_element_complete_register_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_unregister_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_unregister_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_add_route_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_remove_route_aid (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_remove_package_aids (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_secure_element_complete_get_registered_handlers (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *packages);
+
+void net_nfc_gdbus_secure_element_complete_get_handler_storage_info (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint used,
+    gint maximum);
+
+void net_nfc_gdbus_secure_element_complete_get_conflict_handlers (
+    NetNfcGDbusSecureElement *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *packages);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_secure_element_emit_ese_detected (
+    NetNfcGDbusSecureElement *object,
+    guint arg_handle,
+    gint arg_se_type,
+    GVariant *arg_data);
+
+void net_nfc_gdbus_secure_element_emit_se_type_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type);
+
+void net_nfc_gdbus_secure_element_emit_card_emulation_mode_changed (
+    NetNfcGDbusSecureElement *object,
+    gint arg_mode);
+
+void net_nfc_gdbus_secure_element_emit_transaction_event (
+    NetNfcGDbusSecureElement *object,
+    gint arg_se_type,
+    GVariant *arg_aid,
+    GVariant *arg_param,
+    gint arg_fg_dispatch,
+    gint arg_focus_pgid);
+
+void net_nfc_gdbus_secure_element_emit_rf_detected (
+    NetNfcGDbusSecureElement *object);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_secure_element_call_set (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_set_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_set_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get (
+    NetNfcGDbusSecureElement *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_set_card_emulation (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_set_card_emulation_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_set_card_emulation_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_card_emulation (
+    NetNfcGDbusSecureElement *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_card_emulation_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_card_emulation_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_type,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_open_secure_element (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_open_secure_element_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    guint *out_handle,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_open_secure_element_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_type,
+    gint *out_result,
+    guint *out_handle,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_close_secure_element (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_close_secure_element_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_close_secure_element_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_atr (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_atr_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_atr,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_atr_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    gint *out_result,
+    GVariant **out_atr,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_send_apdu (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_send_apdu_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_response,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_send_apdu_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GVariant **out_response,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_set_transaction_fg_dispatch_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gint arg_mode,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_set_default_route (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_switch_on,
+    guint arg_switch_off,
+    guint arg_battery_off,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_set_default_route_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_set_default_route_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_switch_on,
+    guint arg_switch_off,
+    guint arg_battery_off,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_set_preferred_handler (
+    NetNfcGDbusSecureElement *proxy,
+    gboolean arg_state,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_set_preferred_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_set_preferred_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    gboolean arg_state,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_check_transaction_permission (
+    NetNfcGDbusSecureElement *proxy,
+    GVariant *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_check_transaction_permission_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_check_transaction_permission_sync (
+    NetNfcGDbusSecureElement *proxy,
+    GVariant *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_is_activated_aid_handler (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_is_activated_aid_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gboolean *out_activated,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_is_activated_aid_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    const gchar *arg_aid,
+    gint *out_result,
+    gboolean *out_activated,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_is_activated_category_handler (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_is_activated_category_handler_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gboolean *out_activated,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_is_activated_category_handler_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    gboolean *out_activated,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_registered_aids (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_registered_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_aids,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_registered_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    GVariant **out_aids,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_register_aid (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_register_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_register_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_unregister_aid (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_unregister_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_unregister_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_unregister_aids (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_unregister_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_unregister_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_type,
+    guint arg_category,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_add_route_aid (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    guint arg_se_type,
+    guint arg_category,
+    gboolean arg_unlock,
+    guint arg_power,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_add_route_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_add_route_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    guint arg_se_type,
+    guint arg_category,
+    gboolean arg_unlock,
+    guint arg_power,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_remove_route_aid (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_remove_route_aid_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_remove_route_aid_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    const gchar *arg_aid,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_remove_package_aids (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_remove_package_aids_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_remove_package_aids_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_registered_handlers (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_registered_handlers_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_packages,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_registered_handlers_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    gint *out_result,
+    GVariant **out_packages,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_handler_storage_info (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_handler_storage_info_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    gint *out_used,
+    gint *out_maximum,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_handler_storage_info_sync (
+    NetNfcGDbusSecureElement *proxy,
+    guint arg_category,
+    gint *out_result,
+    gint *out_used,
+    gint *out_maximum,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_secure_element_call_get_conflict_handlers (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    guint arg_category,
+    const gchar *arg_aid,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_secure_element_call_get_conflict_handlers_finish (
+    NetNfcGDbusSecureElement *proxy,
+    gint *out_result,
+    GVariant **out_packages,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_secure_element_call_get_conflict_handlers_sync (
+    NetNfcGDbusSecureElement *proxy,
+    const gchar *arg_package,
+    guint arg_category,
+    const gchar *arg_aid,
+    gint *out_result,
+    GVariant **out_packages,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY (net_nfc_gdbus_secure_element_proxy_get_type ())
+#define NET_NFC_GDBUS_SECURE_ELEMENT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, NetNfcGDbusSecureElementProxy))
+#define NET_NFC_GDBUS_SECURE_ELEMENT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, NetNfcGDbusSecureElementProxyClass))
+#define NET_NFC_GDBUS_SECURE_ELEMENT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY, NetNfcGDbusSecureElementProxyClass))
+#define NET_NFC_GDBUS_IS_SECURE_ELEMENT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY))
+#define NET_NFC_GDBUS_IS_SECURE_ELEMENT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_PROXY))
+
+typedef struct _NetNfcGDbusSecureElementProxy NetNfcGDbusSecureElementProxy;
+typedef struct _NetNfcGDbusSecureElementProxyClass NetNfcGDbusSecureElementProxyClass;
+typedef struct _NetNfcGDbusSecureElementProxyPrivate NetNfcGDbusSecureElementProxyPrivate;
+
+struct _NetNfcGDbusSecureElementProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusSecureElementProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusSecureElementProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_secure_element_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusSecureElementProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_secure_element_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_secure_element_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON (net_nfc_gdbus_secure_element_skeleton_get_type ())
+#define NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON, NetNfcGDbusSecureElementSkeleton))
+#define NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON, NetNfcGDbusSecureElementSkeletonClass))
+#define NET_NFC_GDBUS_SECURE_ELEMENT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON, NetNfcGDbusSecureElementSkeletonClass))
+#define NET_NFC_GDBUS_IS_SECURE_ELEMENT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON))
+#define NET_NFC_GDBUS_IS_SECURE_ELEMENT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_SECURE_ELEMENT_SKELETON))
+
+typedef struct _NetNfcGDbusSecureElementSkeleton NetNfcGDbusSecureElementSkeleton;
+typedef struct _NetNfcGDbusSecureElementSkeletonClass NetNfcGDbusSecureElementSkeletonClass;
+typedef struct _NetNfcGDbusSecureElementSkeletonPrivate NetNfcGDbusSecureElementSkeletonPrivate;
+
+struct _NetNfcGDbusSecureElementSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusSecureElementSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusSecureElementSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_secure_element_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusSecureElementSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusSecureElement *net_nfc_gdbus_secure_element_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Transceive */
+
+#define NET_NFC_GDBUS_TYPE_TRANSCEIVE (net_nfc_gdbus_transceive_get_type ())
+#define NET_NFC_GDBUS_TRANSCEIVE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE, NetNfcGDbusTransceive))
+#define NET_NFC_GDBUS_IS_TRANSCEIVE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE))
+#define NET_NFC_GDBUS_TRANSCEIVE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE, NetNfcGDbusTransceiveIface))
+
+struct _NetNfcGDbusTransceive;
+typedef struct _NetNfcGDbusTransceive NetNfcGDbusTransceive;
+typedef struct _NetNfcGDbusTransceiveIface NetNfcGDbusTransceiveIface;
+
+struct _NetNfcGDbusTransceiveIface
+{
+  GTypeInterface parent_iface;
+
+  gboolean (*handle_transceive) (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data);
+
+  gboolean (*handle_transceive_data) (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data);
+
+};
+
+GType net_nfc_gdbus_transceive_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_transceive_interface_info (void);
+guint net_nfc_gdbus_transceive_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_transceive_complete_transceive_data (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    GVariant *resp_data);
+
+void net_nfc_gdbus_transceive_complete_transceive (
+    NetNfcGDbusTransceive *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_transceive_call_transceive_data (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_transceive_call_transceive_data_finish (
+    NetNfcGDbusTransceive *proxy,
+    gint *out_result,
+    GVariant **out_resp_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_transceive_call_transceive_data_sync (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    gint *out_result,
+    GVariant **out_resp_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_transceive_call_transceive (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_transceive_call_transceive_finish (
+    NetNfcGDbusTransceive *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_transceive_call_transceive_sync (
+    NetNfcGDbusTransceive *proxy,
+    guint arg_handle,
+    guint arg_dev_type,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY (net_nfc_gdbus_transceive_proxy_get_type ())
+#define NET_NFC_GDBUS_TRANSCEIVE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, NetNfcGDbusTransceiveProxy))
+#define NET_NFC_GDBUS_TRANSCEIVE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, NetNfcGDbusTransceiveProxyClass))
+#define NET_NFC_GDBUS_TRANSCEIVE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY, NetNfcGDbusTransceiveProxyClass))
+#define NET_NFC_GDBUS_IS_TRANSCEIVE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY))
+#define NET_NFC_GDBUS_IS_TRANSCEIVE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TRANSCEIVE_PROXY))
+
+typedef struct _NetNfcGDbusTransceiveProxy NetNfcGDbusTransceiveProxy;
+typedef struct _NetNfcGDbusTransceiveProxyClass NetNfcGDbusTransceiveProxyClass;
+typedef struct _NetNfcGDbusTransceiveProxyPrivate NetNfcGDbusTransceiveProxyPrivate;
+
+struct _NetNfcGDbusTransceiveProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusTransceiveProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusTransceiveProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_transceive_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTransceiveProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_transceive_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTransceive *net_nfc_gdbus_transceive_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTransceive *net_nfc_gdbus_transceive_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_transceive_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTransceive *net_nfc_gdbus_transceive_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTransceive *net_nfc_gdbus_transceive_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON (net_nfc_gdbus_transceive_skeleton_get_type ())
+#define NET_NFC_GDBUS_TRANSCEIVE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON, NetNfcGDbusTransceiveSkeleton))
+#define NET_NFC_GDBUS_TRANSCEIVE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON, NetNfcGDbusTransceiveSkeletonClass))
+#define NET_NFC_GDBUS_TRANSCEIVE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON, NetNfcGDbusTransceiveSkeletonClass))
+#define NET_NFC_GDBUS_IS_TRANSCEIVE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON))
+#define NET_NFC_GDBUS_IS_TRANSCEIVE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TRANSCEIVE_SKELETON))
+
+typedef struct _NetNfcGDbusTransceiveSkeleton NetNfcGDbusTransceiveSkeleton;
+typedef struct _NetNfcGDbusTransceiveSkeletonClass NetNfcGDbusTransceiveSkeletonClass;
+typedef struct _NetNfcGDbusTransceiveSkeletonPrivate NetNfcGDbusTransceiveSkeletonPrivate;
+
+struct _NetNfcGDbusTransceiveSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusTransceiveSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusTransceiveSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_transceive_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTransceiveSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusTransceive *net_nfc_gdbus_transceive_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Handover */
+
+#define NET_NFC_GDBUS_TYPE_HANDOVER (net_nfc_gdbus_handover_get_type ())
+#define NET_NFC_GDBUS_HANDOVER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HANDOVER, NetNfcGDbusHandover))
+#define NET_NFC_GDBUS_IS_HANDOVER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HANDOVER))
+#define NET_NFC_GDBUS_HANDOVER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_HANDOVER, NetNfcGDbusHandoverIface))
+
+struct _NetNfcGDbusHandover;
+typedef struct _NetNfcGDbusHandover NetNfcGDbusHandover;
+typedef struct _NetNfcGDbusHandoverIface NetNfcGDbusHandoverIface;
+
+struct _NetNfcGDbusHandoverIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_request) (
+    NetNfcGDbusHandover *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    gint arg_type);
+
+  void (*finished) (
+    NetNfcGDbusHandover *object,
+    gint arg_result,
+    gint arg_type,
+    GVariant *arg_address,
+    GVariant *arg_message);
+
+  void (*started) (
+    NetNfcGDbusHandover *object,
+    GVariant *arg_message);
+
+};
+
+GType net_nfc_gdbus_handover_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_handover_interface_info (void);
+guint net_nfc_gdbus_handover_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_handover_complete_request (
+    NetNfcGDbusHandover *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    gint carrier_type,
+    GVariant *handover_data);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_handover_emit_started (
+    NetNfcGDbusHandover *object,
+    GVariant *arg_message);
+
+void net_nfc_gdbus_handover_emit_finished (
+    NetNfcGDbusHandover *object,
+    gint arg_result,
+    gint arg_type,
+    GVariant *arg_address,
+    GVariant *arg_message);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_handover_call_request (
+    NetNfcGDbusHandover *proxy,
+    guint arg_handle,
+    gint arg_type,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_handover_call_request_finish (
+    NetNfcGDbusHandover *proxy,
+    gint *out_result,
+    gint *out_carrier_type,
+    GVariant **out_handover_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_handover_call_request_sync (
+    NetNfcGDbusHandover *proxy,
+    guint arg_handle,
+    gint arg_type,
+    gint *out_result,
+    gint *out_carrier_type,
+    GVariant **out_handover_data,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_HANDOVER_PROXY (net_nfc_gdbus_handover_proxy_get_type ())
+#define NET_NFC_GDBUS_HANDOVER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, NetNfcGDbusHandoverProxy))
+#define NET_NFC_GDBUS_HANDOVER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, NetNfcGDbusHandoverProxyClass))
+#define NET_NFC_GDBUS_HANDOVER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_HANDOVER_PROXY, NetNfcGDbusHandoverProxyClass))
+#define NET_NFC_GDBUS_IS_HANDOVER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HANDOVER_PROXY))
+#define NET_NFC_GDBUS_IS_HANDOVER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_HANDOVER_PROXY))
+
+typedef struct _NetNfcGDbusHandoverProxy NetNfcGDbusHandoverProxy;
+typedef struct _NetNfcGDbusHandoverProxyClass NetNfcGDbusHandoverProxyClass;
+typedef struct _NetNfcGDbusHandoverProxyPrivate NetNfcGDbusHandoverProxyPrivate;
+
+struct _NetNfcGDbusHandoverProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusHandoverProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusHandoverProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_handover_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusHandoverProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_handover_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusHandover *net_nfc_gdbus_handover_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusHandover *net_nfc_gdbus_handover_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_handover_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusHandover *net_nfc_gdbus_handover_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusHandover *net_nfc_gdbus_handover_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON (net_nfc_gdbus_handover_skeleton_get_type ())
+#define NET_NFC_GDBUS_HANDOVER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON, NetNfcGDbusHandoverSkeleton))
+#define NET_NFC_GDBUS_HANDOVER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON, NetNfcGDbusHandoverSkeletonClass))
+#define NET_NFC_GDBUS_HANDOVER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON, NetNfcGDbusHandoverSkeletonClass))
+#define NET_NFC_GDBUS_IS_HANDOVER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON))
+#define NET_NFC_GDBUS_IS_HANDOVER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_HANDOVER_SKELETON))
+
+typedef struct _NetNfcGDbusHandoverSkeleton NetNfcGDbusHandoverSkeleton;
+typedef struct _NetNfcGDbusHandoverSkeletonClass NetNfcGDbusHandoverSkeletonClass;
+typedef struct _NetNfcGDbusHandoverSkeletonPrivate NetNfcGDbusHandoverSkeletonPrivate;
+
+struct _NetNfcGDbusHandoverSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusHandoverSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusHandoverSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_handover_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusHandoverSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusHandover *net_nfc_gdbus_handover_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Test */
+
+#define NET_NFC_GDBUS_TYPE_TEST (net_nfc_gdbus_test_get_type ())
+#define NET_NFC_GDBUS_TEST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TEST, NetNfcGDbusTest))
+#define NET_NFC_GDBUS_IS_TEST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TEST))
+#define NET_NFC_GDBUS_TEST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_TEST, NetNfcGDbusTestIface))
+
+struct _NetNfcGDbusTest;
+typedef struct _NetNfcGDbusTest NetNfcGDbusTest;
+typedef struct _NetNfcGDbusTestIface NetNfcGDbusTestIface;
+
+struct _NetNfcGDbusTestIface
+{
+  GTypeInterface parent_iface;
+
+  gboolean (*handle_ese_test) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_get_firmware_version) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_prbs_test) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_tech,
+    guint arg_rate);
+
+  gboolean (*handle_set_ee_data) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_mode,
+    guint arg_reg_id,
+    GVariant *arg_data);
+
+  gboolean (*handle_set_listen_tech_mask) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_tech);
+
+  gboolean (*handle_set_se_tech_type) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_type,
+    guint arg_tech);
+
+  gboolean (*handle_sim_test) (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation);
+
+};
+
+GType net_nfc_gdbus_test_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_test_interface_info (void);
+guint net_nfc_gdbus_test_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_test_complete_sim_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_test_complete_prbs_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_test_complete_get_firmware_version (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    const gchar *version);
+
+void net_nfc_gdbus_test_complete_set_ee_data (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_test_complete_ese_test (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_test_complete_set_se_tech_type (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_test_complete_set_listen_tech_mask (
+    NetNfcGDbusTest *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_test_call_sim_test (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_sim_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_sim_test_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_prbs_test (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    guint arg_rate,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_prbs_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_prbs_test_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    guint arg_rate,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_get_firmware_version (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_get_firmware_version_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    gchar **out_version,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_get_firmware_version_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    gchar **out_version,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_set_ee_data (
+    NetNfcGDbusTest *proxy,
+    guint arg_mode,
+    guint arg_reg_id,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_set_ee_data_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_set_ee_data_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_mode,
+    guint arg_reg_id,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_ese_test (
+    NetNfcGDbusTest *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_ese_test_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_ese_test_sync (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_set_se_tech_type (
+    NetNfcGDbusTest *proxy,
+    guint arg_type,
+    guint arg_tech,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_set_se_tech_type_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_set_se_tech_type_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_type,
+    guint arg_tech,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_test_call_set_listen_tech_mask (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_test_call_set_listen_tech_mask_finish (
+    NetNfcGDbusTest *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_test_call_set_listen_tech_mask_sync (
+    NetNfcGDbusTest *proxy,
+    guint arg_tech,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TEST_PROXY (net_nfc_gdbus_test_proxy_get_type ())
+#define NET_NFC_GDBUS_TEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TEST_PROXY, NetNfcGDbusTestProxy))
+#define NET_NFC_GDBUS_TEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TEST_PROXY, NetNfcGDbusTestProxyClass))
+#define NET_NFC_GDBUS_TEST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TEST_PROXY, NetNfcGDbusTestProxyClass))
+#define NET_NFC_GDBUS_IS_TEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TEST_PROXY))
+#define NET_NFC_GDBUS_IS_TEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TEST_PROXY))
+
+typedef struct _NetNfcGDbusTestProxy NetNfcGDbusTestProxy;
+typedef struct _NetNfcGDbusTestProxyClass NetNfcGDbusTestProxyClass;
+typedef struct _NetNfcGDbusTestProxyPrivate NetNfcGDbusTestProxyPrivate;
+
+struct _NetNfcGDbusTestProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusTestProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusTestProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_test_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTestProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_test_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTest *net_nfc_gdbus_test_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTest *net_nfc_gdbus_test_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_test_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusTest *net_nfc_gdbus_test_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusTest *net_nfc_gdbus_test_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_TEST_SKELETON (net_nfc_gdbus_test_skeleton_get_type ())
+#define NET_NFC_GDBUS_TEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_TEST_SKELETON, NetNfcGDbusTestSkeleton))
+#define NET_NFC_GDBUS_TEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_TEST_SKELETON, NetNfcGDbusTestSkeletonClass))
+#define NET_NFC_GDBUS_TEST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_TEST_SKELETON, NetNfcGDbusTestSkeletonClass))
+#define NET_NFC_GDBUS_IS_TEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_TEST_SKELETON))
+#define NET_NFC_GDBUS_IS_TEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_TEST_SKELETON))
+
+typedef struct _NetNfcGDbusTestSkeleton NetNfcGDbusTestSkeleton;
+typedef struct _NetNfcGDbusTestSkeletonClass NetNfcGDbusTestSkeletonClass;
+typedef struct _NetNfcGDbusTestSkeletonPrivate NetNfcGDbusTestSkeletonPrivate;
+
+struct _NetNfcGDbusTestSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusTestSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusTestSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_test_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusTestSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusTest *net_nfc_gdbus_test_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Snep */
+
+#define NET_NFC_GDBUS_TYPE_SNEP (net_nfc_gdbus_snep_get_type ())
+#define NET_NFC_GDBUS_SNEP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SNEP, NetNfcGDbusSnep))
+#define NET_NFC_GDBUS_IS_SNEP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SNEP))
+#define NET_NFC_GDBUS_SNEP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_SNEP, NetNfcGDbusSnepIface))
+
+struct _NetNfcGDbusSnep;
+typedef struct _NetNfcGDbusSnep NetNfcGDbusSnep;
+typedef struct _NetNfcGDbusSnepIface NetNfcGDbusSnepIface;
+
+struct _NetNfcGDbusSnepIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_client_request) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_snep_handle,
+    guint arg_type,
+    GVariant *arg_ndef_msg);
+
+  gboolean (*handle_client_start) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data);
+
+  gboolean (*handle_server_register) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data);
+
+  gboolean (*handle_server_start) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data);
+
+  gboolean (*handle_server_unregister) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_sap,
+    const gchar *arg_san);
+
+  gboolean (*handle_stop_snep) (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    guint arg_snep_handle);
+
+  void (*snep_event) (
+    NetNfcGDbusSnep *object,
+    guint arg_handle,
+    guint arg_event,
+    gint arg_result,
+    GVariant *arg_ndef_msg,
+    guint arg_user_data);
+
+};
+
+GType net_nfc_gdbus_snep_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_snep_interface_info (void);
+guint net_nfc_gdbus_snep_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_snep_complete_server_register (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_snep_complete_server_unregister (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_snep_complete_server_start (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_snep_complete_client_start (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_snep_complete_client_request (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result,
+    guint type,
+    GVariant *data);
+
+void net_nfc_gdbus_snep_complete_stop_snep (
+    NetNfcGDbusSnep *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_snep_emit_snep_event (
+    NetNfcGDbusSnep *object,
+    guint arg_handle,
+    guint arg_event,
+    gint arg_result,
+    GVariant *arg_ndef_msg,
+    guint arg_user_data);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_snep_call_server_register (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_server_register_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_server_register_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_snep_call_server_unregister (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_server_unregister_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_server_unregister_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_sap,
+    const gchar *arg_san,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_snep_call_server_start (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_server_start_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_server_start_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_snep_call_client_start (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_client_start_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_client_start_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_sap,
+    const gchar *arg_san,
+    guint arg_user_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_snep_call_client_request (
+    NetNfcGDbusSnep *proxy,
+    guint arg_snep_handle,
+    guint arg_type,
+    GVariant *arg_ndef_msg,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_client_request_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    guint *out_type,
+    GVariant **out_data,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_client_request_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_snep_handle,
+    guint arg_type,
+    GVariant *arg_ndef_msg,
+    gint *out_result,
+    guint *out_type,
+    GVariant **out_data,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_snep_call_stop_snep (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_snep_handle,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_snep_call_stop_snep_finish (
+    NetNfcGDbusSnep *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_snep_call_stop_snep_sync (
+    NetNfcGDbusSnep *proxy,
+    guint arg_handle,
+    guint arg_snep_handle,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_SNEP_PROXY (net_nfc_gdbus_snep_proxy_get_type ())
+#define NET_NFC_GDBUS_SNEP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SNEP_PROXY, NetNfcGDbusSnepProxy))
+#define NET_NFC_GDBUS_SNEP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_SNEP_PROXY, NetNfcGDbusSnepProxyClass))
+#define NET_NFC_GDBUS_SNEP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_SNEP_PROXY, NetNfcGDbusSnepProxyClass))
+#define NET_NFC_GDBUS_IS_SNEP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SNEP_PROXY))
+#define NET_NFC_GDBUS_IS_SNEP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_SNEP_PROXY))
+
+typedef struct _NetNfcGDbusSnepProxy NetNfcGDbusSnepProxy;
+typedef struct _NetNfcGDbusSnepProxyClass NetNfcGDbusSnepProxyClass;
+typedef struct _NetNfcGDbusSnepProxyPrivate NetNfcGDbusSnepProxyPrivate;
+
+struct _NetNfcGDbusSnepProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusSnepProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusSnepProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_snep_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusSnepProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_snep_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusSnep *net_nfc_gdbus_snep_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusSnep *net_nfc_gdbus_snep_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_snep_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusSnep *net_nfc_gdbus_snep_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusSnep *net_nfc_gdbus_snep_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_SNEP_SKELETON (net_nfc_gdbus_snep_skeleton_get_type ())
+#define NET_NFC_GDBUS_SNEP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_SNEP_SKELETON, NetNfcGDbusSnepSkeleton))
+#define NET_NFC_GDBUS_SNEP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_SNEP_SKELETON, NetNfcGDbusSnepSkeletonClass))
+#define NET_NFC_GDBUS_SNEP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_SNEP_SKELETON, NetNfcGDbusSnepSkeletonClass))
+#define NET_NFC_GDBUS_IS_SNEP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_SNEP_SKELETON))
+#define NET_NFC_GDBUS_IS_SNEP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_SNEP_SKELETON))
+
+typedef struct _NetNfcGDbusSnepSkeleton NetNfcGDbusSnepSkeleton;
+typedef struct _NetNfcGDbusSnepSkeletonClass NetNfcGDbusSnepSkeletonClass;
+typedef struct _NetNfcGDbusSnepSkeletonPrivate NetNfcGDbusSnepSkeletonPrivate;
+
+struct _NetNfcGDbusSnepSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusSnepSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusSnepSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_snep_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusSnepSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusSnep *net_nfc_gdbus_snep_skeleton_new (void);
+
+
+/* ------------------------------------------------------------------------ */
+/* Declarations for org.tizen.NetNfcService.Hce */
+
+#define NET_NFC_GDBUS_TYPE_HCE (net_nfc_gdbus_hce_get_type ())
+#define NET_NFC_GDBUS_HCE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HCE, NetNfcGDbusHce))
+#define NET_NFC_GDBUS_IS_HCE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HCE))
+#define NET_NFC_GDBUS_HCE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), NET_NFC_GDBUS_TYPE_HCE, NetNfcGDbusHceIface))
+
+struct _NetNfcGDbusHce;
+typedef struct _NetNfcGDbusHce NetNfcGDbusHce;
+typedef struct _NetNfcGDbusHceIface NetNfcGDbusHceIface;
+
+struct _NetNfcGDbusHceIface
+{
+  GTypeInterface parent_iface;
+
+
+  gboolean (*handle_response_apdu) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    guint arg_handle,
+    GVariant *arg_data);
+
+  gboolean (*handle_start_hce_handler) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation);
+
+  gboolean (*handle_stop_hce_handler) (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation);
+
+  void (*event_received) (
+    NetNfcGDbusHce *object,
+    guint arg_handle,
+    guint arg_event,
+    GVariant *arg_apdu);
+
+};
+
+GType net_nfc_gdbus_hce_get_type (void) G_GNUC_CONST;
+
+GDBusInterfaceInfo *net_nfc_gdbus_hce_interface_info (void);
+guint net_nfc_gdbus_hce_override_properties (GObjectClass *klass, guint property_id_begin);
+
+
+/* D-Bus method call completion functions: */
+void net_nfc_gdbus_hce_complete_start_hce_handler (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_hce_complete_stop_hce_handler (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+void net_nfc_gdbus_hce_complete_response_apdu (
+    NetNfcGDbusHce *object,
+    GDBusMethodInvocation *invocation,
+    gint result);
+
+
+
+/* D-Bus signal emissions functions: */
+void net_nfc_gdbus_hce_emit_event_received (
+    NetNfcGDbusHce *object,
+    guint arg_handle,
+    guint arg_event,
+    GVariant *arg_apdu);
+
+
+
+/* D-Bus method calls: */
+void net_nfc_gdbus_hce_call_start_hce_handler (
+    NetNfcGDbusHce *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_hce_call_start_hce_handler_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_hce_call_start_hce_handler_sync (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_hce_call_stop_hce_handler (
+    NetNfcGDbusHce *proxy,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_hce_call_stop_hce_handler_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_hce_call_stop_hce_handler_sync (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+void net_nfc_gdbus_hce_call_response_apdu (
+    NetNfcGDbusHce *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    GCancellable *cancellable,
+    GAsyncReadyCallback callback,
+    gpointer user_data);
+
+gboolean net_nfc_gdbus_hce_call_response_apdu_finish (
+    NetNfcGDbusHce *proxy,
+    gint *out_result,
+    GAsyncResult *res,
+    GError **error);
+
+gboolean net_nfc_gdbus_hce_call_response_apdu_sync (
+    NetNfcGDbusHce *proxy,
+    guint arg_handle,
+    GVariant *arg_data,
+    gint *out_result,
+    GCancellable *cancellable,
+    GError **error);
+
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_HCE_PROXY (net_nfc_gdbus_hce_proxy_get_type ())
+#define NET_NFC_GDBUS_HCE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HCE_PROXY, NetNfcGDbusHceProxy))
+#define NET_NFC_GDBUS_HCE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_HCE_PROXY, NetNfcGDbusHceProxyClass))
+#define NET_NFC_GDBUS_HCE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_HCE_PROXY, NetNfcGDbusHceProxyClass))
+#define NET_NFC_GDBUS_IS_HCE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HCE_PROXY))
+#define NET_NFC_GDBUS_IS_HCE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_HCE_PROXY))
+
+typedef struct _NetNfcGDbusHceProxy NetNfcGDbusHceProxy;
+typedef struct _NetNfcGDbusHceProxyClass NetNfcGDbusHceProxyClass;
+typedef struct _NetNfcGDbusHceProxyPrivate NetNfcGDbusHceProxyPrivate;
+
+struct _NetNfcGDbusHceProxy
+{
+  /*< private >*/
+  GDBusProxy parent_instance;
+  NetNfcGDbusHceProxyPrivate *priv;
+};
+
+struct _NetNfcGDbusHceProxyClass
+{
+  GDBusProxyClass parent_class;
+};
+
+GType net_nfc_gdbus_hce_proxy_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusHceProxy, g_object_unref)
+#endif
+
+void net_nfc_gdbus_hce_proxy_new (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusHce *net_nfc_gdbus_hce_proxy_new_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusHce *net_nfc_gdbus_hce_proxy_new_sync (
+    GDBusConnection     *connection,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+void net_nfc_gdbus_hce_proxy_new_for_bus (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GAsyncReadyCallback  callback,
+    gpointer             user_data);
+NetNfcGDbusHce *net_nfc_gdbus_hce_proxy_new_for_bus_finish (
+    GAsyncResult        *res,
+    GError             **error);
+NetNfcGDbusHce *net_nfc_gdbus_hce_proxy_new_for_bus_sync (
+    GBusType             bus_type,
+    GDBusProxyFlags      flags,
+    const gchar         *name,
+    const gchar         *object_path,
+    GCancellable        *cancellable,
+    GError             **error);
+
+
+/* ---- */
+
+#define NET_NFC_GDBUS_TYPE_HCE_SKELETON (net_nfc_gdbus_hce_skeleton_get_type ())
+#define NET_NFC_GDBUS_HCE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NET_NFC_GDBUS_TYPE_HCE_SKELETON, NetNfcGDbusHceSkeleton))
+#define NET_NFC_GDBUS_HCE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), NET_NFC_GDBUS_TYPE_HCE_SKELETON, NetNfcGDbusHceSkeletonClass))
+#define NET_NFC_GDBUS_HCE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NET_NFC_GDBUS_TYPE_HCE_SKELETON, NetNfcGDbusHceSkeletonClass))
+#define NET_NFC_GDBUS_IS_HCE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NET_NFC_GDBUS_TYPE_HCE_SKELETON))
+#define NET_NFC_GDBUS_IS_HCE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NET_NFC_GDBUS_TYPE_HCE_SKELETON))
+
+typedef struct _NetNfcGDbusHceSkeleton NetNfcGDbusHceSkeleton;
+typedef struct _NetNfcGDbusHceSkeletonClass NetNfcGDbusHceSkeletonClass;
+typedef struct _NetNfcGDbusHceSkeletonPrivate NetNfcGDbusHceSkeletonPrivate;
+
+struct _NetNfcGDbusHceSkeleton
+{
+  /*< private >*/
+  GDBusInterfaceSkeleton parent_instance;
+  NetNfcGDbusHceSkeletonPrivate *priv;
+};
+
+struct _NetNfcGDbusHceSkeletonClass
+{
+  GDBusInterfaceSkeletonClass parent_class;
+};
+
+GType net_nfc_gdbus_hce_skeleton_get_type (void) G_GNUC_CONST;
+
+#if GLIB_CHECK_VERSION(2, 44, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (NetNfcGDbusHceSkeleton, g_object_unref)
+#endif
+
+NetNfcGDbusHce *net_nfc_gdbus_hce_skeleton_new (void);
+
+
+G_END_DECLS
+
+#endif /* __NET_NFC_GDBUS_H__ */
diff --git a/unittest/run_coverage.sh b/unittest/run_coverage.sh
new file mode 100755 (executable)
index 0000000..f7471d5
--- /dev/null
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+export LD_LIBRARY_PATH=..:.:$LD_LIBRARY_PATH
+pushd ../
+RootDir=$PWD
+popd
+
+unitTestFile=tct-nfc-core
+if [ ! -x  "./$unitTestFile" ]
+then
+    echo "$unitTestFile file does not exist!"
+    exit -1
+fi
+
+LD_PRELOAD=./libnfc-mock.so ./$unitTestFile
+
+CMakeDir=${RootDir}/CMakeFiles/capi-network-nfc.dir/src
+CoverageDir=${RootDir}/coverage
+
+pushd $CMakeDir
+
+    for obj in `ls *.o`
+    do
+        gcov -b -c $obj
+    done
+
+    if [ -f /usr/bin/lcov ]
+    then
+        lcov -c -d . -o cov.info
+        genhtml cov.info -o ${CoverageDir}
+        echo "Coverage test result created! [${CoverageDir}]"
+    else
+        echo "lcov does not exist!"
+    fi
+popd
diff --git a/unittest/tct-nfc-core.cpp b/unittest/tct-nfc-core.cpp
new file mode 100755 (executable)
index 0000000..6d3a2ff
--- /dev/null
@@ -0,0 +1,95 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stdio.h>
+#include <string.h>
+#include "tct_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tct-nfc-core.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <gtest/gtest.h>
+
+#include <malloc.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <stdbool.h>
+
+TEST(nfc, nfc){
+       char *pszGetTCName = NULL;
+       pszGetTCName = (char*)malloc( 256 );
+       memset( pszGetTCName, 0x00, 256);
+       strcpy( pszGetTCName, "utc_nfc");
+       int i=0, result=0;
+
+       printf("[%s:%d] Executing TC Name = %s\n", __FUNCTION__, __LINE__, pszGetTCName);
+
+       int successCnt = 0;
+       int errorCnt = 0;
+       for ( i = 0; tc_array[i].name; i++ )
+       {
+               if ( 0 == strncmp(pszGetTCName, tc_array[i].name, strlen(pszGetTCName)) )
+               {
+                       printf("[%d] %s start\n", i, tc_array[i].name);
+                       if ( tc_array[i].startup )
+                       {
+                               tc_array[i].startup();
+                       }
+
+                       result = tc_array[i].function();
+
+                       if( result == 0 ) {
+                               successCnt++;
+                       } else {
+                               printf("[Error][%d] %s returns value = %d\n", i, tc_array[i].name, result);
+                               errorCnt++;
+                       }
+
+                       EXPECT_EQ(result, 0);
+
+                       if ( tc_array[i].cleanup )
+                       {
+                               tc_array[i].cleanup();
+                       }
+                       printf("[%d] %s cleanup\n", i, tc_array[i].name);
+               }
+               else
+               {
+                       dlog_print(DLOG_INFO, "NativeTCT", "Name check error! [%s][%s]", pszGetTCName, tc_array[i].name);
+                       ASSERT_EQ(0, 1);
+               }
+       }
+
+       dlog_print(DLOG_INFO, "NativeTCT", "==========================");
+       dlog_print(DLOG_INFO, "NativeTCT", "Success [%4d / %4d]", successCnt, successCnt + errorCnt);
+       dlog_print(DLOG_INFO, "NativeTCT", "Error   [%4d / %4d]", errorCnt, successCnt + errorCnt);
+       dlog_print(DLOG_INFO, "NativeTCT", "==========================");
+
+       FREE_MEMORY_TC(pszGetTCName);
+}
+
+int main(int argc, char** argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/unittest/tct-nfc-core.h b/unittest/tct-nfc-core.h
new file mode 100755 (executable)
index 0000000..bf40360
--- /dev/null
@@ -0,0 +1,360 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef __TCT_NFC_NATIVE_H__
+#define __TCT_NFC_NATIVE_H__
+
+#include "testcase.h"
+#include "tct_common.h"
+
+extern void utc_nfc_startup(void);
+extern void utc_nfc_cleanup(void);
+extern void utc_nfc_snep_startup(void);
+extern void utc_nfc_snep_cleanup(void);
+extern void utc_ce_startup(void);
+extern void utc_ce_cleanup(void);
+extern void utc_nfc_ndef_message_startup(void);
+extern void utc_nfc_ndef_message_cleanup(void);
+extern void utc_nfc_ndef_record_startup(void);
+extern void utc_nfc_ndef_record_cleanup(void);
+extern void utc_nfc_se_hce_startup(void);
+extern void utc_nfc_se_hce_cleanup(void);
+
+extern int utc_nfc_manager_is_supported_p(void);
+extern int utc_nfc_manager_initialize_p(void);
+extern int utc_nfc_manager_deinitialize_p(void);
+extern int utc_nfc_manager_set_activation_changed_cb_p(void);
+extern int utc_nfc_manager_set_activation_changed_cb_n(void);
+extern int utc_nfc_manager_unset_activation_changed_cb_p(void);
+extern int utc_nfc_manager_unset_activation_changed_cb_n(void);
+extern int utc_nfc_manager_unset_tag_discovered_cb_p(void);
+extern int utc_nfc_manager_unset_tag_discovered_cb_n(void);
+extern int utc_nfc_manager_unset_ndef_discovered_cb_p(void);
+extern int utc_nfc_manager_unset_ndef_discovered_cb_n(void);
+extern int utc_nfc_manager_unset_p2p_target_discovered_cb_p(void);
+extern int utc_nfc_manager_unset_p2p_target_discovered_cb_n(void);
+extern int utc_nfc_manager_is_activated_p(void);
+extern int utc_nfc_manager_set_tag_discovered_cb_p(void);
+extern int utc_nfc_manager_set_tag_discovered_cb_n(void);
+extern int utc_nfc_manager_set_ndef_discovered_cb_p(void);
+extern int utc_nfc_manager_set_ndef_discovered_cb_n(void);
+extern int utc_nfc_manager_set_p2p_target_discovered_cb_p(void);
+extern int utc_nfc_manager_set_p2p_target_discovered_cb_n(void);
+extern int utc_nfc_manager_set_system_handler_enable_p1(void);
+extern int utc_nfc_manager_set_system_handler_enable_p2(void);
+extern int utc_nfc_manager_set_system_handler_enable_n(void);
+extern int utc_nfc_manager_get_se_type_p(void);
+extern int utc_nfc_manager_get_se_type_n(void);
+extern int utc_nfc_manager_set_se_type_p(void);
+extern int utc_nfc_manager_set_se_type_n(void);
+extern int utc_nfc_manager_get_cached_message_n(void);
+extern int utc_nfc_manager_get_connected_tag_n(void);
+extern int utc_nfc_manager_get_connected_target_n(void);
+extern int utc_nfc_manager_set_tag_filter_p(void);
+extern int utc_nfc_manager_set_tag_filter_n(void);
+extern int utc_nfc_manager_get_tag_filter_p(void);
+extern int utc_nfc_manager_get_tag_filter_n(void);
+extern int utc_nfc_manager_is_system_handler_enabled_p(void);
+extern int utc_nfc_manager_is_system_handler_enabled_n(void);
+extern int utc_nfc_tag_get_type_n(void);
+extern int utc_nfc_tag_is_support_ndef_n(void);
+extern int utc_nfc_tag_get_maximum_ndef_size_n(void);
+extern int utc_nfc_tag_get_ndef_size_n(void);
+extern int utc_nfc_tag_foreach_information_n(void);
+extern int utc_nfc_tag_transceive_n(void);
+extern int utc_nfc_tag_read_ndef_n(void);
+extern int utc_nfc_tag_write_ndef_n(void);
+extern int utc_nfc_tag_format_ndef_n(void);
+extern int utc_nfc_mifare_authenticate_with_keyA_n(void);
+extern int utc_nfc_mifare_authenticate_with_keyB_n(void);
+extern int utc_nfc_mifare_read_block_n(void);
+extern int utc_nfc_mifare_read_page_n(void);
+extern int utc_nfc_mifare_write_block_n(void);
+extern int utc_nfc_mifare_write_page_n(void);
+extern int utc_nfc_mifare_increment_n(void);
+extern int utc_nfc_mifare_decrement_n(void);
+extern int utc_nfc_mifare_transfer_n(void);
+extern int utc_nfc_mifare_restore_n(void);
+extern int utc_nfc_p2p_set_data_received_cb_n(void);
+extern int utc_nfc_p2p_unset_data_received_cb_n(void);
+extern int utc_nfc_p2p_send_n(void);
+extern int utc_nfc_snep_register_server_p(void);
+extern int utc_nfc_snep_register_server_n1(void);
+extern int utc_nfc_snep_register_server_n2(void);
+extern int utc_nfc_snep_unregister_server_p(void);
+extern int utc_nfc_snep_unregister_server_n(void);
+extern int utc_nfc_snep_send_client_request_n(void);
+extern int utc_nfc_snep_start_client_n(void);
+extern int utc_nfc_snep_start_server_n(void);
+extern int utc_nfc_snep_stop_service_n(void);
+extern int utc_nfc_se_enable_card_emulation_p(void);
+extern int utc_nfc_se_enable_card_emulation_n(void);
+extern int utc_nfc_se_disable_card_emulation_p(void);
+extern int utc_nfc_se_disable_card_emulation_n(void);
+extern int utc_nfc_se_get_card_emulation_mode_p(void);
+extern int utc_nfc_se_get_card_emulation_mode_n(void);
+extern int utc_nfc_se_set_preferred_handler_n(void);
+extern int utc_nfc_se_unset_preferred_handler_p(void);
+extern int utc_nfc_se_unset_preferred_handler_n(void);
+extern int utc_nfc_manager_set_se_event_cb_p(void);
+extern int utc_nfc_manager_set_se_event_cb_n(void);
+extern int utc_nfc_manager_unset_se_event_cb_p(void);
+extern int utc_nfc_manager_unset_se_event_cb_n(void);
+extern int utc_nfc_manager_set_se_transaction_event_cb_p1(void);
+extern int utc_nfc_manager_set_se_transaction_event_cb_p2(void);
+extern int utc_nfc_manager_set_se_transaction_event_cb_n1(void);
+extern int utc_nfc_manager_set_se_transaction_event_cb_n2(void);
+extern int utc_nfc_manager_set_se_transaction_event_cb_n3(void);
+extern int utc_nfc_manager_unset_se_transaction_event_cb_p(void);
+extern int utc_nfc_manager_unset_se_transaction_event_cb_n(void);
+extern int utc_nfc_manager_enable_transaction_fg_dispatch_p(void);
+extern int utc_nfc_manager_enable_transaction_fg_dispatch_n(void);
+extern int utc_nfc_manager_disable_transaction_fg_dispatch_p(void);
+extern int utc_nfc_manager_disable_transaction_fg_dispatch_n(void);
+extern int utc_nfc_ndef_message_create_p(void);
+extern int utc_nfc_ndef_message_create_n(void);
+extern int utc_nfc_ndef_message_create_from_rawdata_p(void);
+extern int utc_nfc_ndef_message_create_from_rawdata_n1(void);
+extern int utc_nfc_ndef_message_create_from_rawdata_n2(void);
+extern int utc_nfc_ndef_message_destroy_p(void);
+extern int utc_nfc_ndef_message_destroy_n(void);
+extern int utc_nfc_ndef_message_get_record_count_p(void);
+extern int utc_nfc_ndef_message_get_record_count_n1(void);
+extern int utc_nfc_ndef_message_get_record_count_n2(void);
+extern int utc_nfc_ndef_message_get_rawdata_p(void);
+extern int utc_nfc_ndef_message_get_rawdata_n(void);
+extern int utc_nfc_ndef_message_append_record_p(void);
+extern int utc_nfc_ndef_message_append_record_n(void);
+extern int utc_nfc_ndef_message_insert_record_p(void);
+extern int utc_nfc_ndef_message_insert_record_n(void);
+extern int utc_nfc_ndef_message_remove_record_p(void);
+extern int utc_nfc_ndef_message_remove_record_n(void);
+extern int utc_nfc_ndef_message_get_record_p(void);
+extern int utc_nfc_ndef_message_get_record_n(void);
+extern int utc_nfc_ndef_record_create_p(void);
+extern int utc_nfc_ndef_record_create_n(void);
+extern int utc_nfc_ndef_record_create_text_p(void);
+extern int utc_nfc_ndef_record_create_text_n(void);
+extern int utc_nfc_ndef_record_create_uri_p(void);
+extern int utc_nfc_ndef_record_create_uri_n(void);
+extern int utc_nfc_ndef_record_create_mime_p(void);
+extern int utc_nfc_ndef_record_create_mime_n_1(void);
+extern int utc_nfc_ndef_record_create_mime_n_2(void);
+extern int utc_nfc_ndef_record_create_mime_n_3(void);
+extern int utc_nfc_ndef_record_destroy_p(void);
+extern int utc_nfc_ndef_record_destroy_n(void);
+extern int utc_nfc_ndef_record_set_id_p(void);
+extern int utc_nfc_ndef_record_set_id_n(void);
+extern int utc_nfc_ndef_record_get_id_p(void);
+extern int utc_nfc_ndef_record_get_id_n(void);
+extern int utc_nfc_ndef_record_get_payload_p(void);
+extern int utc_nfc_ndef_record_get_payload_n(void);
+extern int utc_nfc_ndef_record_get_type_p(void);
+extern int utc_nfc_ndef_record_get_type_n(void);
+extern int utc_nfc_ndef_record_get_tnf_p(void);
+extern int utc_nfc_ndef_record_get_tnf_n(void);
+extern int utc_nfc_ndef_record_get_text_p(void);
+extern int utc_nfc_ndef_record_get_text_n(void);
+extern int utc_nfc_ndef_record_get_langcode_p(void);
+extern int utc_nfc_ndef_record_get_langcode_n(void);
+extern int utc_nfc_ndef_record_get_encode_type_p(void);
+extern int utc_nfc_ndef_record_get_encode_type_n(void);
+extern int utc_nfc_ndef_record_get_uri_p(void);
+extern int utc_nfc_ndef_record_get_uri_n(void);
+extern int utc_nfc_ndef_record_get_mime_type_p(void);
+extern int utc_nfc_ndef_record_get_mime_type_n(void);
+extern int utc_nfc_manager_set_hce_event_cb_p(void);
+extern int utc_nfc_manager_set_hce_event_cb_n(void);
+extern int utc_nfc_manager_unset_hce_event_cb_p(void);
+extern int utc_nfc_manager_unset_hce_event_cb_n(void);
+extern int utc_nfc_se_set_default_route_p(void);
+extern int utc_nfc_se_set_default_route_n(void);
+extern int utc_nfc_se_is_activated_handler_for_aid_p(void);
+extern int utc_nfc_se_is_activated_handler_for_aid_n(void);
+extern int utc_nfc_se_is_activated_handler_for_category_p(void);
+extern int utc_nfc_se_is_activated_handler_for_category_n(void);
+extern int utc_nfc_se_register_aid_p(void);
+extern int utc_nfc_se_register_aid_n(void);
+extern int utc_nfc_se_unregister_aid_p(void);
+extern int utc_nfc_se_unregister_aid_n(void);
+extern int utc_nfc_se_foreach_registered_aids_p(void);
+extern int utc_nfc_se_foreach_registered_aids_n(void);
+extern int utc_nfc_hce_send_apdu_response_n(void);
+
+testcase tc_array[] = {
+       {"utc_nfc_manager_is_supported_p",utc_nfc_manager_is_supported_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_initialize_p",utc_nfc_manager_initialize_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_deinitialize_p",utc_nfc_manager_deinitialize_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_activation_changed_cb_p",utc_nfc_manager_set_activation_changed_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_activation_changed_cb_n",utc_nfc_manager_set_activation_changed_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_activation_changed_cb_p",utc_nfc_manager_unset_activation_changed_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_activation_changed_cb_n",utc_nfc_manager_unset_activation_changed_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_tag_discovered_cb_p",utc_nfc_manager_unset_tag_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_tag_discovered_cb_n",utc_nfc_manager_unset_tag_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_ndef_discovered_cb_p",utc_nfc_manager_unset_ndef_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_ndef_discovered_cb_n",utc_nfc_manager_unset_ndef_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_p2p_target_discovered_cb_p",utc_nfc_manager_unset_p2p_target_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_unset_p2p_target_discovered_cb_n",utc_nfc_manager_unset_p2p_target_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_is_activated_p",utc_nfc_manager_is_activated_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_tag_discovered_cb_p",utc_nfc_manager_set_tag_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_tag_discovered_cb_n",utc_nfc_manager_set_tag_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_ndef_discovered_cb_p",utc_nfc_manager_set_ndef_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_ndef_discovered_cb_n",utc_nfc_manager_set_ndef_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_p2p_target_discovered_cb_p",utc_nfc_manager_set_p2p_target_discovered_cb_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_p2p_target_discovered_cb_n",utc_nfc_manager_set_p2p_target_discovered_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_system_handler_enable_p1",utc_nfc_manager_set_system_handler_enable_p1,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_system_handler_enable_p2",utc_nfc_manager_set_system_handler_enable_p2,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_system_handler_enable_n",utc_nfc_manager_set_system_handler_enable_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_se_type_p",utc_nfc_manager_get_se_type_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_se_type_n",utc_nfc_manager_get_se_type_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_se_type_p",utc_nfc_manager_set_se_type_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_se_type_n",utc_nfc_manager_set_se_type_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_cached_message_n",utc_nfc_manager_get_cached_message_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_connected_tag_n",utc_nfc_manager_get_connected_tag_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_connected_target_n",utc_nfc_manager_get_connected_target_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_tag_filter_p",utc_nfc_manager_set_tag_filter_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_set_tag_filter_n",utc_nfc_manager_set_tag_filter_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_tag_filter_p",utc_nfc_manager_get_tag_filter_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_get_tag_filter_n",utc_nfc_manager_get_tag_filter_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_is_system_handler_enabled_p",utc_nfc_manager_is_system_handler_enabled_p,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_manager_is_system_handler_enabled_n",utc_nfc_manager_is_system_handler_enabled_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_get_type_n",utc_nfc_tag_get_type_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_is_support_ndef_n",utc_nfc_tag_is_support_ndef_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_get_maximum_ndef_size_n",utc_nfc_tag_get_maximum_ndef_size_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_get_ndef_size_n",utc_nfc_tag_get_ndef_size_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_foreach_information_n",utc_nfc_tag_foreach_information_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_transceive_n",utc_nfc_tag_transceive_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_read_ndef_n",utc_nfc_tag_read_ndef_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_write_ndef_n",utc_nfc_tag_write_ndef_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_tag_format_ndef_n",utc_nfc_tag_format_ndef_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_authenticate_with_keyA_n",utc_nfc_mifare_authenticate_with_keyA_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_authenticate_with_keyB_n",utc_nfc_mifare_authenticate_with_keyB_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_read_block_n",utc_nfc_mifare_read_block_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_read_page_n",utc_nfc_mifare_read_page_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_write_block_n",utc_nfc_mifare_write_block_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_write_page_n",utc_nfc_mifare_write_page_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_increment_n",utc_nfc_mifare_increment_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_decrement_n",utc_nfc_mifare_decrement_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_transfer_n",utc_nfc_mifare_transfer_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_mifare_restore_n",utc_nfc_mifare_restore_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_p2p_set_data_received_cb_n",utc_nfc_p2p_set_data_received_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_p2p_unset_data_received_cb_n",utc_nfc_p2p_unset_data_received_cb_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_p2p_send_n",utc_nfc_p2p_send_n,utc_nfc_startup,utc_nfc_cleanup},
+       {"utc_nfc_snep_register_server_p",utc_nfc_snep_register_server_p,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_register_server_n1",utc_nfc_snep_register_server_n1,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_register_server_n2",utc_nfc_snep_register_server_n2,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_unregister_server_p",utc_nfc_snep_unregister_server_p,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_unregister_server_n",utc_nfc_snep_unregister_server_n,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_send_client_request_n",utc_nfc_snep_send_client_request_n,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_start_client_n",utc_nfc_snep_start_client_n,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_start_server_n",utc_nfc_snep_start_server_n,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_snep_stop_service_n",utc_nfc_snep_stop_service_n,utc_nfc_snep_startup,utc_nfc_snep_cleanup},
+       {"utc_nfc_se_enable_card_emulation_p",utc_nfc_se_enable_card_emulation_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_enable_card_emulation_n",utc_nfc_se_enable_card_emulation_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_disable_card_emulation_p",utc_nfc_se_disable_card_emulation_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_disable_card_emulation_n",utc_nfc_se_disable_card_emulation_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_get_card_emulation_mode_p",utc_nfc_se_get_card_emulation_mode_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_get_card_emulation_mode_n",utc_nfc_se_get_card_emulation_mode_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_set_preferred_handler_n",utc_nfc_se_set_preferred_handler_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_unset_preferred_handler_p",utc_nfc_se_unset_preferred_handler_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_se_unset_preferred_handler_n",utc_nfc_se_unset_preferred_handler_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_event_cb_p",utc_nfc_manager_set_se_event_cb_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_event_cb_n",utc_nfc_manager_set_se_event_cb_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_unset_se_event_cb_p",utc_nfc_manager_unset_se_event_cb_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_unset_se_event_cb_n",utc_nfc_manager_unset_se_event_cb_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_transaction_event_cb_p1",utc_nfc_manager_set_se_transaction_event_cb_p1,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_transaction_event_cb_p2",utc_nfc_manager_set_se_transaction_event_cb_p2,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_transaction_event_cb_n1",utc_nfc_manager_set_se_transaction_event_cb_n1,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_transaction_event_cb_n2",utc_nfc_manager_set_se_transaction_event_cb_n2,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_set_se_transaction_event_cb_n3",utc_nfc_manager_set_se_transaction_event_cb_n3,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_unset_se_transaction_event_cb_p",utc_nfc_manager_unset_se_transaction_event_cb_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_unset_se_transaction_event_cb_n",utc_nfc_manager_unset_se_transaction_event_cb_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_enable_transaction_fg_dispatch_p",utc_nfc_manager_enable_transaction_fg_dispatch_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_enable_transaction_fg_dispatch_n",utc_nfc_manager_enable_transaction_fg_dispatch_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_disable_transaction_fg_dispatch_p",utc_nfc_manager_disable_transaction_fg_dispatch_p,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_manager_disable_transaction_fg_dispatch_n",utc_nfc_manager_disable_transaction_fg_dispatch_n,utc_ce_startup,utc_ce_cleanup},
+       {"utc_nfc_ndef_message_create_p",utc_nfc_ndef_message_create_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_create_n",utc_nfc_ndef_message_create_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_create_from_rawdata_p",utc_nfc_ndef_message_create_from_rawdata_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_create_from_rawdata_n1",utc_nfc_ndef_message_create_from_rawdata_n1,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_create_from_rawdata_n2",utc_nfc_ndef_message_create_from_rawdata_n2,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_destroy_p",utc_nfc_ndef_message_destroy_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_destroy_n",utc_nfc_ndef_message_destroy_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_record_count_p",utc_nfc_ndef_message_get_record_count_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_record_count_n1",utc_nfc_ndef_message_get_record_count_n1,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_record_count_n2",utc_nfc_ndef_message_get_record_count_n2,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_rawdata_p",utc_nfc_ndef_message_get_rawdata_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_rawdata_n",utc_nfc_ndef_message_get_rawdata_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_append_record_p",utc_nfc_ndef_message_append_record_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_append_record_n",utc_nfc_ndef_message_append_record_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_insert_record_p",utc_nfc_ndef_message_insert_record_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_insert_record_n",utc_nfc_ndef_message_insert_record_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_remove_record_p",utc_nfc_ndef_message_remove_record_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_remove_record_n",utc_nfc_ndef_message_remove_record_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_record_p",utc_nfc_ndef_message_get_record_p,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_message_get_record_n",utc_nfc_ndef_message_get_record_n,utc_nfc_ndef_message_startup,utc_nfc_ndef_message_cleanup},
+       {"utc_nfc_ndef_record_create_p",utc_nfc_ndef_record_create_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_n",utc_nfc_ndef_record_create_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_text_p",utc_nfc_ndef_record_create_text_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_text_n",utc_nfc_ndef_record_create_text_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_uri_p",utc_nfc_ndef_record_create_uri_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_uri_n",utc_nfc_ndef_record_create_uri_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_mime_p",utc_nfc_ndef_record_create_mime_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_mime_n_1",utc_nfc_ndef_record_create_mime_n_1,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_mime_n_2",utc_nfc_ndef_record_create_mime_n_2,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_create_mime_n_3",utc_nfc_ndef_record_create_mime_n_3,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_destroy_p",utc_nfc_ndef_record_destroy_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_destroy_n",utc_nfc_ndef_record_destroy_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_set_id_p",utc_nfc_ndef_record_set_id_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_set_id_n",utc_nfc_ndef_record_set_id_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_id_p",utc_nfc_ndef_record_get_id_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_id_n",utc_nfc_ndef_record_get_id_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_payload_p",utc_nfc_ndef_record_get_payload_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_payload_n",utc_nfc_ndef_record_get_payload_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_type_p",utc_nfc_ndef_record_get_type_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_type_n",utc_nfc_ndef_record_get_type_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_tnf_p",utc_nfc_ndef_record_get_tnf_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_tnf_n",utc_nfc_ndef_record_get_tnf_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_text_p",utc_nfc_ndef_record_get_text_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_text_n",utc_nfc_ndef_record_get_text_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_langcode_p",utc_nfc_ndef_record_get_langcode_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_langcode_n",utc_nfc_ndef_record_get_langcode_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_encode_type_p",utc_nfc_ndef_record_get_encode_type_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_encode_type_n",utc_nfc_ndef_record_get_encode_type_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_uri_p",utc_nfc_ndef_record_get_uri_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_uri_n",utc_nfc_ndef_record_get_uri_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_mime_type_p",utc_nfc_ndef_record_get_mime_type_p,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_ndef_record_get_mime_type_n",utc_nfc_ndef_record_get_mime_type_n,utc_nfc_ndef_record_startup,utc_nfc_ndef_record_cleanup},
+       {"utc_nfc_manager_set_hce_event_cb_p",utc_nfc_manager_set_hce_event_cb_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_manager_set_hce_event_cb_n",utc_nfc_manager_set_hce_event_cb_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_manager_unset_hce_event_cb_p",utc_nfc_manager_unset_hce_event_cb_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_manager_unset_hce_event_cb_n",utc_nfc_manager_unset_hce_event_cb_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_set_default_route_p",utc_nfc_se_set_default_route_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_set_default_route_n",utc_nfc_se_set_default_route_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_is_activated_handler_for_aid_p",utc_nfc_se_is_activated_handler_for_aid_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_is_activated_handler_for_aid_n",utc_nfc_se_is_activated_handler_for_aid_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_is_activated_handler_for_category_p",utc_nfc_se_is_activated_handler_for_category_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_is_activated_handler_for_category_n",utc_nfc_se_is_activated_handler_for_category_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_register_aid_p",utc_nfc_se_register_aid_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_register_aid_n",utc_nfc_se_register_aid_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_unregister_aid_p",utc_nfc_se_unregister_aid_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_unregister_aid_n",utc_nfc_se_unregister_aid_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_foreach_registered_aids_p",utc_nfc_se_foreach_registered_aids_p,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_se_foreach_registered_aids_n",utc_nfc_se_foreach_registered_aids_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {"utc_nfc_hce_send_apdu_response_n",utc_nfc_hce_send_apdu_response_n,utc_nfc_se_hce_startup,utc_nfc_se_hce_cleanup},
+       {NULL, NULL}
+};
+
+#endif // __TCT_NFC_NATIVE_H__
diff --git a/unittest/utc-network-nfc-hce.c b/unittest/utc-network-nfc-hce.c
new file mode 100755 (executable)
index 0000000..946a58f
--- /dev/null
@@ -0,0 +1,435 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "assert_local.h"
+#include <nfc.h>
+#include <glib.h>
+#include <system_info.h>
+
+//& set: HCE
+static bool hce_supported=false;
+
+/**
+ * @function           utc_nfc_se_hce_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_se_hce_startup(void)
+{
+       nfc_manager_initialize();
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation.hce",&hce_supported);
+}
+
+/**
+ * @function           utc_nfc_se_hce_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_se_hce_cleanup(void)
+{
+    nfc_manager_deinitialize();
+}
+
+void _nfc_hce_event_cb(nfc_se_h handle, nfc_hce_event_type_e event,
+       unsigned char *apdu, unsigned int apdu_len, void *user_data)
+{
+
+}
+
+void _nfc_se_registered_aid_cb(nfc_se_type_e se_type,  const char *aid, bool read_only, void *user_data)
+{
+
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_hce_event_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_hce_event_cb_p(void)
+{
+       int ret;
+
+       ret = nfc_manager_set_hce_event_cb(_nfc_hce_event_cb, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+   }
+       else{
+               assert_eq(ret, NFC_ERROR_OPERATION_FAILED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_hce_event_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_hce_event_cb_n(void)
+{
+       int ret;
+
+       ret = nfc_manager_set_hce_event_cb(NULL, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+   }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_hce_event_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_hce_event_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_hce_event_cb();
+
+       ret = get_last_result();
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+   }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_hce_event_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_hce_event_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       nfc_manager_unset_hce_event_cb();
+
+       ret = get_last_result();
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+   }
+       else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+/**
+ * @testcase           utc_nfc_se_set_default_route_p
+ * @since_tizen                2.3
+ * @remarks            This API can return a security error depending on the security level of the manufacturer.
+ *                     If you want to know about security level in detail, See the GSMA specification.\n
+ *                     (http://www.gsma.com/digitalcommerce/wp-content/uploads/2013/12/GSMA-NFC05-NFC-Handset-APIs-Requirement-Specification-version-4-1.pdf)
+ * @description
+ */
+int utc_nfc_se_set_default_route_p(void)
+{
+       int ret;
+       ret = nfc_se_set_default_route(NFC_SE_TYPE_HCE, NFC_SE_TYPE_DISABLE, NFC_SE_TYPE_DISABLE);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert(ret == NFC_ERROR_NONE
+                       || ret == NFC_ERROR_SECURITY_RESTRICTED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_set_default_route_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_set_default_route_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       ret = nfc_se_set_default_route(NFC_SE_TYPE_HCE, NFC_SE_TYPE_DISABLE, NFC_SE_TYPE_DISABLE);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_is_activated_handler_for_aid_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_is_activated_handler_for_aid_p(void)
+{
+       int ret;
+       const char aid[] = "11121314";
+       bool activated_handler;
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+
+       ret = nfc_se_is_activated_handler_for_aid(NFC_SE_TYPE_HCE, aid, &activated_handler);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_is_activated_handler_for_aid_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_is_activated_handler_for_aid_n(void)
+{
+       int ret;
+
+       ret = nfc_se_is_activated_handler_for_aid(NFC_SE_TYPE_HCE, NULL, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_is_activated_handler_for_category_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_is_activated_handler_for_category_p(void)
+{
+       int ret;
+       const char aid[] = "11121314";
+       bool activated_handler;
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+
+       ret = nfc_se_is_activated_handler_for_category(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, &activated_handler);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_is_activated_handler_for_category_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_is_activated_handler_for_category_n(void)
+{
+       int ret;
+
+       ret = nfc_se_is_activated_handler_for_category(NFC_SE_TYPE_HCE, 0, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_register_aid_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_register_aid_p(void)
+{
+       int ret;
+       const char aid[] = "11121314";
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_register_aid_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_register_aid_n(void)
+{
+       int ret;
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_unregister_aid_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_unregister_aid_p(void)
+{
+       int ret;
+       const char aid[] = "11121314";
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+       ret = nfc_se_unregister_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_unregister_aid_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_unregister_aid_n(void)
+{
+       int ret;
+
+       ret = nfc_se_unregister_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_foreach_registered_aids_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_foreach_registered_aids_p(void)
+{
+       int ret;
+       const char aid[] = "11121314";
+
+       ret = nfc_se_register_aid(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, aid);
+
+       ret = nfc_se_foreach_registered_aids(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, _nfc_se_registered_aid_cb, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_foreach_registered_aids_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_foreach_registered_aids_n(void)
+{
+       int ret;
+
+       ret = nfc_se_foreach_registered_aids(NFC_SE_TYPE_HCE, NFC_CARD_EMULATION_CATEGORY_PAYMENT, NULL, NULL);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_hce_send_apdu_response_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_hce_send_apdu_response_n(void)
+{
+       int ret;
+
+       ret = nfc_hce_send_apdu_response(NULL, NULL, 0);
+
+       if(!hce_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
diff --git a/unittest/utc-network-nfc-ndef-message.c b/unittest/utc-network-nfc-ndef-message.c
new file mode 100755 (executable)
index 0000000..7dd2da1
--- /dev/null
@@ -0,0 +1,514 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "assert_local.h"
+#include <nfc.h>
+#include <glib.h>
+#include <system_info.h>
+
+//& set: Nfc-ndef
+static bool nfc_supported=false;
+
+/**
+ * @function           utc_nfc_ndef_message_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_ndef_message_startup(void)
+{
+       nfc_manager_initialize();
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc",&nfc_supported);
+}
+
+/**
+ * @function           utc_nfc_ndef_message_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_ndef_message_cleanup(void)
+{
+    nfc_manager_deinitialize();
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_create_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_create_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+
+    ret = nfc_ndef_message_create(&message);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+           nfc_ndef_message_destroy(message);
+       }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_create_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_create_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_create(NULL);
+
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_create_from_rawdata_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_create_from_rawdata_p(void)
+{
+    int ret;
+    unsigned char *buffer;
+    unsigned int size;
+    nfc_ndef_message_h message;
+    nfc_ndef_message_h message2;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+        assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        nfc_ndef_message_append_record(message, record1);
+        nfc_ndef_message_get_rawdata(message, &buffer, &size);
+        ret = nfc_ndef_message_create_from_rawdata(&message2, buffer, size);
+
+        nfc_ndef_message_destroy(message2);
+        nfc_ndef_message_destroy(message);
+        free(buffer);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_create_from_rawdata_n1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_create_from_rawdata_n1(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_create_from_rawdata(NULL, NULL, 0);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_create_from_rawdata_n2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_create_from_rawdata_n2(void)
+{
+    int ret;
+    nfc_ndef_message_h message2;
+
+    ret = nfc_ndef_message_create_from_rawdata(&message2, NULL, 0);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_destroy_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_destroy_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+        assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_message_destroy(message);
+
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_destroy_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_destroy_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_destroy(NULL);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_record_count_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_record_count_p(void)
+{
+    int ret;
+    int count;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+        assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        nfc_ndef_message_append_record(message, record1);
+        ret = nfc_ndef_message_get_record_count(message, &count);
+        nfc_ndef_message_destroy(message);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_record_count_n1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_record_count_n1(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+
+    ret = nfc_ndef_message_create(&message);
+    if(nfc_supported){
+
+        assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_message_get_record_count(message, NULL);
+        assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+    }
+    else{
+        ret = nfc_ndef_message_get_record_count(message, NULL);
+        assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_record_count_n2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_record_count_n2(void)
+{
+    int ret;
+    int count;
+
+    ret = nfc_ndef_message_get_record_count(NULL, &count);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_rawdata_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_rawdata_p(void)
+{
+    int ret;
+    unsigned char *buffer;
+    unsigned int size;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        nfc_ndef_message_append_record(message, record1);
+        ret = nfc_ndef_message_get_rawdata(message, &buffer, &size);
+        nfc_ndef_message_destroy(message);
+        free(buffer);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_rawdata_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_rawdata_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_get_rawdata(NULL, NULL, NULL);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_append_record_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_append_record_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+        assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        ret = nfc_ndef_message_append_record(message, record1);
+        nfc_ndef_message_destroy(message);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_append_record_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_append_record_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_append_record(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_insert_record_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_insert_record_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+        assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        ret = nfc_ndef_message_insert_record(message, 0, record1);
+        nfc_ndef_message_destroy(message);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_insert_record_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_insert_record_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_insert_record(NULL, 0, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_remove_record_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_remove_record_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        ret = nfc_ndef_message_insert_record(message, 0, record1);
+       assert_eq(ret,NFC_ERROR_NONE);
+       ret = nfc_ndef_message_remove_record(message, 0);
+        nfc_ndef_message_destroy(message);
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_remove_record_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_remove_record_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_remove_record(NULL, 0);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_record_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_record_p(void)
+{
+    int ret;
+    nfc_ndef_message_h message;
+    nfc_ndef_record_h record1, record2;
+
+    ret = nfc_ndef_message_create(&message);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        nfc_ndef_record_create_text(&record1, "test", "en-US", NFC_ENCODE_UTF_8);
+        ret = nfc_ndef_message_insert_record(message, 0, record1);
+       assert_eq(ret,NFC_ERROR_NONE);
+       ret = nfc_ndef_message_get_record(message, 0, &record2);
+        nfc_ndef_message_destroy(message);
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_message_get_record_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_message_get_record_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_message_get_record(NULL, 0, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
diff --git a/unittest/utc-network-nfc-ndef-record.c b/unittest/utc-network-nfc-ndef-record.c
new file mode 100755 (executable)
index 0000000..fcef9f8
--- /dev/null
@@ -0,0 +1,760 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "assert_local.h"
+#include <nfc.h>
+#include <glib.h>
+#include <system_info.h>
+
+//& set: Nfc-ndef
+static bool nfc_supported;
+
+/**
+ * @function           utc_nfc_ndef_record_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_ndef_record_startup(void)
+{
+       nfc_manager_initialize();
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc",&nfc_supported);
+}
+
+/**
+ * @function           utc_nfc_ndef_record_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_ndef_record_cleanup(void)
+{
+       nfc_manager_deinitialize();
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+    unsigned char testbuffer[] = "TEST";
+
+    ret = nfc_ndef_record_create(&record, NFC_RECORD_TNF_WELL_KNOWN, testbuffer, 1, testbuffer, 4, testbuffer, 4);
+    if(!nfc_supported){
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_n(void)
+{
+    int ret;
+    unsigned char testbuffer[] = "TEST";
+
+    ret = nfc_ndef_record_create(NULL, NFC_RECORD_TNF_WELL_KNOWN, testbuffer, 1, testbuffer, 4, testbuffer, 4);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_text_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_text_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+       ret= nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_text_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_text_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_create_text(NULL, "test", "en-US", NFC_ENCODE_UTF_8);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_uri_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_uri_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_uri(&record, "http://test.com");
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+       ret= nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_uri_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_uri_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_create_uri(NULL, "http://test.com");
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_mime_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_mime_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_mime(&record, "text/plain", (unsigned char *)"the text record", sizeof("the text record"));
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret, NFC_ERROR_NONE);
+       ret= nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_mime_n_1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_mime_n_1(void)
+{
+    int ret = NFC_ERROR_NONE;
+
+    ret = nfc_ndef_record_create_mime(NULL, "text/plain", (unsigned char *)"the text record", sizeof("the text record"));
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_mime_n_2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_mime_n_2(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_mime(&record, NULL, (unsigned char *)"the text record", sizeof("the text record"));
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_create_mime_n_3
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_create_mime_n_3(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_mime(&record, "text/plain", NULL, sizeof("the text record"));
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_destroy_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_destroy_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_destroy_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_destroy_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_destroy(NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_set_id_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_set_id_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_set_id(record, (unsigned char *)"test", 4);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_set_id_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_set_id_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_set_id(NULL, (unsigned char *)"test", 4);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_id_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_id_p(void)
+{
+    int ret;
+    int size;
+    nfc_ndef_record_h record;
+    unsigned char *id;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_set_id(record, (unsigned char *)"test", 4);
+        assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_id(record, &id, &size);
+        nfc_ndef_record_destroy(record);
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_id_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_id_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_id(NULL, NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_payload_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_payload_p(void)
+{
+    int ret;
+    unsigned int size;
+    nfc_ndef_record_h record;
+    unsigned char *payload;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+
+        ret = nfc_ndef_record_get_payload(record, &payload, &size);
+
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_payload_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_payload_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_set_id(NULL, (unsigned char *)"test", 4);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_type_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_type_p(void)
+{
+    int ret;
+    int size;
+    nfc_ndef_record_h record;
+    unsigned char *data;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_type(record, &data, &size);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_type_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_type(NULL, NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_tnf_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_tnf_p(void)
+{
+    int ret;
+    nfc_ndef_record_h record;
+    nfc_record_tnf_e tnf;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_tnf(record, &tnf);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_tnf_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_tnf_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_tnf(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_text_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_text_p(void)
+{
+    int ret;
+    char *text;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_text(record, &text);
+       assert_eq(ret,NFC_ERROR_NONE);
+        free(text);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_text_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_text_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_text(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_langcode_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_langcode_p(void)
+{
+    int ret;
+    char *text;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_langcode(record, &text);
+        assert_eq(ret,NFC_ERROR_NONE);
+        free(text);
+        nfc_ndef_record_destroy(record);
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+
+}
+/**
+ * @testcase           utc_nfc_ndef_record_get_langcode_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_langcode_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_langcode(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_encode_type_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_encode_type_p(void)
+{
+    int ret;
+    nfc_encode_type_e type;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_text(&record, "test", "en-US", NFC_ENCODE_UTF_8);
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+       assert_eq(ret,NFC_ERROR_NONE);
+
+        ret = nfc_ndef_record_get_encode_type(record, &type);
+
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_encode_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_encode_type_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_encode_type(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_uri_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_uri_p(void)
+{
+    int ret;
+    char *uri;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_uri(&record, "http://test.com");
+
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_uri(record, &uri);
+               assert_eq(ret,NFC_ERROR_NONE);
+        free(uri);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_uri_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_uri_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_uri(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_mime_type_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_mime_type_p(void)
+{
+    int ret;
+    char *mime_type;
+    nfc_ndef_record_h record;
+
+    ret = nfc_ndef_record_create_mime(&record, "text/plain", (unsigned char *)"the text record", sizeof("the text record"));
+    if(!nfc_supported){ assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);}
+    else{
+
+       assert_eq(ret,NFC_ERROR_NONE);
+        ret = nfc_ndef_record_get_mime_type(record, &mime_type);
+        assert_eq(ret,NFC_ERROR_NONE);
+        free(mime_type);
+        nfc_ndef_record_destroy(record);
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_ndef_record_get_mime_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_ndef_record_get_mime_type_n(void)
+{
+    int ret;
+
+    ret = nfc_ndef_record_get_mime_type(NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+    return 0;
+}
diff --git a/unittest/utc-network-nfc.c b/unittest/utc-network-nfc.c
new file mode 100755 (executable)
index 0000000..f0ebcda
--- /dev/null
@@ -0,0 +1,2105 @@
+//
+// Copyright (c) 2020 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "assert_local.h"
+#include <nfc.h>
+#include <glib.h>
+#include <system_info.h>
+
+#define NOT_USED(var) ((var) = (var))
+
+//& set: Nfc
+static int _startup_ret = NFC_ERROR_NONE;
+static bool nfc_supported=false;
+static bool nfc_tag_supported=false;
+static bool nfc_p2p_supported=false;
+static bool nfc_ce_supported=false;
+static bool nfc_ce_hce_supported=false;
+
+/**
+ * @function           utc_nfc_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_startup(void)
+{
+    _startup_ret = nfc_manager_initialize();
+
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc",&nfc_supported);
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.tag",&nfc_tag_supported);
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.p2p",&nfc_p2p_supported);
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&nfc_ce_supported);
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation.hce",&nfc_ce_hce_supported);
+}
+
+/**
+ * @function           utc_nfc_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_cleanup(void)
+{
+    nfc_manager_deinitialize();
+}
+
+static void _activation_changed_cb(bool activated, void *user_data)
+{
+}
+
+static void _utc_tag_discovered_cb(nfc_discovered_type_e type,
+        nfc_tag_h tag, void *user_data)
+{
+}
+
+static void _utc_ndef_discovered_cb(nfc_ndef_message_h message, void *user_data)
+{
+}
+
+static void _utc_p2p_discovered_cb(nfc_discovered_type_e type,
+        nfc_p2p_target_h target, void *user_data)
+{
+}
+
+static void _utc_se_event_cb(nfc_se_event_e event , void *user_data)
+{
+}
+
+static void _utc_se_transaction_event_cb(nfc_se_type_e se_type,
+        unsigned char* aid, int aid_size , unsigned char* param,
+        int param_size,  void *user_data)
+{
+}
+
+/**
+ * @testcase           utc_nfc_manager_is_supported_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_is_supported_p(void)
+{
+
+    int result;
+
+    nfc_manager_is_supported();
+    result = get_last_result();
+    if(!nfc_supported){
+
+        assert_eq(result,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+        assert_eq(result, NFC_ERROR_NONE);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_initialize_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_initialize_p(void)
+{
+    int ret = NFC_ERROR_NONE;
+    nfc_manager_deinitialize();
+    ret = nfc_manager_initialize();
+    if(!nfc_supported){
+
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_deinitialize_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_deinitialize_p(void)
+{
+    int ret;
+
+    ret = nfc_manager_deinitialize();
+    if(!nfc_supported){
+
+       assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_activation_changed_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_activation_changed_cb_p(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_activation_changed_cb(_activation_changed_cb, NULL);
+    if(!nfc_supported){
+
+       assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+       assert_eq(ret, NFC_ERROR_NONE);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_activation_changed_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_activation_changed_cb_n(void)
+{
+
+    int ret;
+
+    ret = nfc_manager_set_activation_changed_cb(NULL, NULL);
+    if(!nfc_supported){
+
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+        assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_activation_changed_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_activation_changed_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_activation_changed_cb();
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_activation_changed_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_activation_changed_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+
+       nfc_manager_unset_activation_changed_cb();
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+          assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+       }
+       else{
+           assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_tag_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_tag_discovered_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_tag_discovered_cb();
+
+       ret = get_last_result();
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_tag_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_tag_discovered_cb_n(void)
+{
+       int ret;
+       nfc_manager_deinitialize();
+
+       nfc_manager_unset_tag_discovered_cb();
+
+       ret = get_last_result();
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_ndef_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_ndef_discovered_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_ndef_discovered_cb();
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_ndef_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_ndef_discovered_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+
+       nfc_manager_unset_ndef_discovered_cb();
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+        }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_p2p_target_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_p2p_target_discovered_cb_p(void)
+{
+       int ret;
+       nfc_manager_unset_p2p_target_discovered_cb();
+
+       ret = get_last_result();
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_p2p_target_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_p2p_target_discovered_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+
+       nfc_manager_unset_p2p_target_discovered_cb();
+
+       ret = get_last_result();
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_is_activated_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_is_activated_p(void)
+{
+       int result;
+       nfc_manager_is_activated();
+
+       result = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(result,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(result, NFC_ERROR_NONE);
+        }
+
+        return 0;
+}
+
+
+
+/**
+ * @testcase           utc_nfc_manager_set_tag_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_tag_discovered_cb_p(void)
+{
+       int ret;
+
+       ret = nfc_manager_set_tag_discovered_cb(_utc_tag_discovered_cb, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_tag_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_tag_discovered_cb_n(void)
+{
+       int ret;
+       ret = nfc_manager_set_tag_discovered_cb(NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_ndef_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_ndef_discovered_cb_p(void)
+{
+        int ret;
+
+        ret = nfc_manager_set_ndef_discovered_cb(_utc_ndef_discovered_cb, NULL);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+        return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_ndef_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_ndef_discovered_cb_n(void)
+{
+        int ret;
+
+        ret = nfc_manager_set_ndef_discovered_cb(NULL, NULL);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+        return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_p2p_target_discovered_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_p2p_target_discovered_cb_p(void)
+{
+       int ret;
+
+       ret = nfc_manager_set_p2p_target_discovered_cb(_utc_p2p_discovered_cb, NULL);
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_p2p_target_discovered_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_p2p_target_discovered_cb_n(void)
+{
+       int ret;
+
+       ret = nfc_manager_set_p2p_target_discovered_cb(NULL, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_system_handler_enable_p1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_system_handler_enable_p1(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_system_handler_enable(true);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_system_handler_enable_p2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_system_handler_enable_p2(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_system_handler_enable(false);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_system_handler_enable_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_system_handler_enable_n(void)
+{
+    int ret;
+
+    nfc_manager_deinitialize();
+
+    ret = nfc_manager_set_system_handler_enable(false);
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_se_type_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_se_type_p(void)
+{
+    int ret;
+    nfc_se_type_e tp;
+    bool ce_supported=false;
+
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&ce_supported);
+    ret = nfc_manager_get_se_type(&tp);
+
+    if(ce_supported){
+
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+    else{
+
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_se_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_se_type_n(void)
+{
+    int ret;
+    bool ce_supported=false;
+
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&ce_supported);
+
+    ret = nfc_manager_get_se_type(NULL);
+    if(ce_supported){
+
+       assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+    }
+    else{
+
+        assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_type_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_type_p(void)
+{
+    int ret;
+    nfc_se_type_e tp;
+    bool ce_supported=false;
+
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&ce_supported);
+
+    if(ce_supported){
+        ret = nfc_manager_get_se_type(&tp);
+        if(tp == NFC_SE_TYPE_DISABLE) nfc_manager_set_se_type(NFC_SE_TYPE_ESE);
+    }
+    else{
+       ret=nfc_manager_set_se_type(NFC_SE_TYPE_ESE);
+       assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+    }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_type_n(void)
+{
+    int ret;
+    bool ce_supported=false;
+
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&ce_supported);
+
+    ret = nfc_manager_set_se_type(-3);
+    if(ce_supported){
+
+        assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+    }
+    else{
+
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_cached_message_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_cached_message_n(void)
+{
+    int ret;
+
+    ret = nfc_manager_get_cached_message(NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_connected_tag_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_connected_tag_n(void)
+{
+       int ret;
+
+       ret = nfc_manager_get_connected_tag(NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_connected_target_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_connected_target_n(void)
+{
+       int ret;
+
+       ret = nfc_manager_get_connected_target(NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_tag_filter_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_tag_filter_p(void)
+{
+       int filter;
+       int ret;
+
+       nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
+       filter = nfc_manager_get_tag_filter();
+       ret = get_last_result();
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(filter, NFC_TAG_FILTER_ALL_ENABLE);
+       }
+
+       nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_DISABLE);
+       filter = nfc_manager_get_tag_filter();
+       ret = get_last_result();
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(filter,NFC_TAG_FILTER_ALL_DISABLE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_tag_filter_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_tag_filter_n(void)
+{
+       int ret;
+
+       nfc_manager_set_tag_filter(-999);
+
+       ret = get_last_result();
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_tag_filter_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_tag_filter_p(void)
+{
+       int filter;
+       int ret;
+
+       nfc_manager_set_tag_filter(NFC_TAG_FILTER_ISO14443A_ENABLE);
+       filter = nfc_manager_get_tag_filter();
+       ret = get_last_result();
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(filter, NFC_TAG_FILTER_ISO14443A_ENABLE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_get_tag_filter_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_get_tag_filter_n(void)
+{
+       int ret;
+       int filter = 0;
+
+       nfc_manager_deinitialize();
+
+       filter = nfc_manager_get_tag_filter();
+
+       NOT_USED(filter);
+
+       ret = get_last_result();
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_is_system_handler_enabled_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_is_system_handler_enabled_p(void)
+{
+    int ret;
+    bool enabled;
+
+    enabled = nfc_manager_is_system_handler_enabled();
+
+        NOT_USED(enabled);
+
+    ret = get_last_result();
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_is_system_handler_enabled_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_is_system_handler_enabled_n(void)
+{
+       int ret;
+       bool enabled;
+
+       nfc_manager_deinitialize();
+
+       enabled = nfc_manager_is_system_handler_enabled();
+
+       NOT_USED(enabled);
+
+   ret = get_last_result();
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+        }
+
+    return 0;
+}
+
+//& Set: Tag
+
+/**
+ * @testcase           utc_nfc_tag_get_type_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_get_type_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_get_type(NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_is_support_ndef_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_is_support_ndef_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_is_support_ndef(NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_get_maximum_ndef_size_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_get_maximum_ndef_size_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_get_maximum_ndef_size(NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_get_ndef_size_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_get_ndef_size_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_get_ndef_size(NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_foreach_information_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_foreach_information_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_foreach_information(NULL, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_transceive_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_transceive_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_transceive(NULL, NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_read_ndef_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_read_ndef_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_read_ndef(NULL, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_write_ndef_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_write_ndef_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_write_ndef(NULL, NULL, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_tag_format_ndef_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_tag_format_ndef_n(void)
+{
+       int ret;
+
+       ret = nfc_tag_format_ndef(NULL, NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_authenticate_with_keyA_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_authenticate_with_keyA_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_authenticate_with_keyA(NULL, 0, NULL, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_authenticate_with_keyB_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_authenticate_with_keyB_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_authenticate_with_keyB(NULL, 0, NULL, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_read_block_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_read_block_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_read_block(NULL, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_read_page_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_read_page_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_read_page(NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_write_block_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_write_block_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_write_block(NULL, 0, NULL, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_write_page_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_write_page_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_write_page(NULL, 0, NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_increment_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_increment_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_increment(NULL, 0, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_decrement_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_decrement_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_decrement(NULL, 0, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_transfer_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_transfer_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_transfer(NULL, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_mifare_restore_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_mifare_restore_n(void)
+{
+       int ret;
+
+       ret = nfc_mifare_restore(NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_tag_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_p2p_set_data_received_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_p2p_set_data_received_cb_n(void)
+{
+       int ret;
+
+       ret = nfc_p2p_set_data_received_cb(NULL, NULL, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_p2p_unset_data_received_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_p2p_unset_data_received_cb_n(void)
+{
+       int ret;
+
+       ret = nfc_p2p_unset_data_received_cb(NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_p2p_send_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_p2p_send_n(void)
+{
+       int ret;
+
+       ret = nfc_p2p_send(NULL, NULL, NULL, NULL);
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+//& set: SNEP
+/**
+ * @function           utc_nfc_snep_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_snep_startup(void)
+{
+    _startup_ret = nfc_manager_initialize();
+    system_info_get_platform_bool("http://tizen.org/feature/network.nfc",&nfc_supported);
+}
+
+/**
+ * @function           utc_nfc_snep_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_nfc_snep_cleanup(void)
+{
+    nfc_manager_deinitialize();
+}
+
+static const char *san = "abcd:efgh";
+static int sap = 0x22;
+
+static void _snep_event_cb(nfc_p2p_snep_h handle,
+    nfc_snep_event_e event, nfc_error_e result,
+    nfc_ndef_message_h msg, void *user_data)
+{
+
+}
+
+/**
+ * @testcase           utc_nfc_snep_register_server_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_register_server_p(void)
+{
+       int ret;
+
+       ret = nfc_snep_register_server(san, sap, _snep_event_cb, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+               nfc_snep_unregister_server(san,sap);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_register_server_n1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_register_server_n1(void)
+{
+       int ret;
+
+       ret = nfc_snep_register_server(san, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_register_server_n2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_register_server_n2(void)
+{
+       int ret;
+
+       ret = nfc_snep_register_server(NULL, sap, NULL, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_unregister_server_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_unregister_server_p(void)
+{
+       int ret;
+
+       ret = nfc_snep_register_server(san, sap, _snep_event_cb, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       ret = nfc_snep_unregister_server(san, sap);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_unregister_server_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_unregister_server_n(void)
+{
+       int ret;
+
+       ret = nfc_snep_unregister_server(san, sap);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_OPERATION_FAILED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_send_client_request_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_send_client_request_n(void)
+{
+       int ret;
+
+       ret = nfc_snep_send_client_request(NULL, 0, NULL, NULL, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_start_client_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_start_client_n(void)
+{
+       int ret;
+
+       ret = nfc_snep_start_client(NULL, NULL, 0, NULL, NULL);
+
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_snep_start_server_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_start_server_n(void)
+{
+       int ret;
+       ret = nfc_snep_start_server(NULL, NULL, 0, NULL, NULL);
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+
+/**
+ * @testcase           utc_nfc_snep_stop_service_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_snep_stop_service_n(void)
+{
+       int ret;
+
+       ret = nfc_snep_stop_service(NULL, NULL);
+       if (!nfc_supported || !nfc_p2p_supported) {
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       } else {
+               assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+       }
+
+       return 0;
+}
+
+/**
+ * @function           utc_ce_startup
+ * @description                Called before each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_ce_startup(void)
+{
+       _startup_ret = nfc_manager_initialize();
+       system_info_get_platform_bool("http://tizen.org/feature/network.nfc.card_emulation",&nfc_supported);
+}
+
+/**
+ * @function           utc_ce_cleanup
+ * @description                Called after each test
+ * @parameter          NA
+ * @return                     NA
+ */
+void utc_ce_cleanup(void)
+{
+    nfc_manager_deinitialize();
+}
+
+/**
+ * @testcase           utc_nfc_se_enable_card_emulation_p
+ * @since_tizen                2.3
+ * @remarks             This API can return a security error depending on the security level of the manufacturer.
+ *                      If you want to know about security level in detail, See the GSMA specification.\n
+ *                      (http://www.gsma.com/digitalcommerce/wp-content/uploads/2013/12/GSMA-NFC05-NFC-Handset-APIs-Requirement-Specification-version-4-1.pdf)
+ * @description
+ */
+int utc_nfc_se_enable_card_emulation_p(void)
+{
+       int ret;
+
+       ret = nfc_se_enable_card_emulation();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert(ret == NFC_ERROR_NONE
+                       || ret == NFC_ERROR_ILLEGAL_STATE
+                       || ret == NFC_ERROR_SECURITY_RESTRICTED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_enable_card_emulation_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_enable_card_emulation_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       ret = nfc_se_enable_card_emulation();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_disable_card_emulation_p
+ * @since_tizen                2.3
+ * @remarks             This API can return a security error depending on the security level of the manufacturer.
+ *                      If you want to know about security level in detail, See the GSMA specification.\n
+ *                      (http://www.gsma.com/digitalcommerce/wp-content/uploads/2013/12/GSMA-NFC05-NFC-Handset-APIs-Requirement-Specification-version-4-1.pdf)
+ * @description
+ */
+int utc_nfc_se_disable_card_emulation_p(void)
+{
+       int ret;
+
+       ret = nfc_se_disable_card_emulation();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert(ret == NFC_ERROR_NONE
+                       || ret == NFC_ERROR_SECURITY_RESTRICTED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_disable_card_emulation_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_disable_card_emulation_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       ret = nfc_se_disable_card_emulation();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_get_card_emulation_mode_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_get_card_emulation_mode_p(void)
+{
+       int ret;
+       nfc_se_card_emulation_mode_type_e emode;
+
+       ret = nfc_se_get_card_emulation_mode(&emode);
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_se_get_card_emulation_mode_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_se_get_card_emulation_mode_n(void)
+{
+    int ret;
+
+    ret = nfc_se_get_card_emulation_mode(NULL);
+
+        if(!nfc_supported){
+                assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+        }else{
+                assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase            utc_nfc_se_set_preferred_handler_n
+ * @since_tizen         3.0
+ * @description
+ */
+int utc_nfc_se_set_preferred_handler_n(void)
+{
+    int ret;
+
+    nfc_manager_deinitialize();
+    ret = nfc_se_set_preferred_handler();
+
+         if(!nfc_supported){
+                 assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+         }else{
+                 assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+         }
+
+    return 0;
+}
+
+/**
+ * @testcase            utc_nfc_se_unset_preferred_handler_p
+ * @since_tizen         3.0
+ * @description
+ */
+int utc_nfc_se_unset_preferred_handler_p(void)
+{
+    int ret;
+
+    ret = nfc_se_unset_preferred_handler();
+
+         if(!nfc_supported){
+                 assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+         }else{
+                 assert_eq(ret, NFC_ERROR_NONE);
+         }
+
+    return 0;
+}
+
+/**
+ * @testcase            utc_nfc_se_unset_preferred_handler_n
+ * @since_tizen         3.0
+ * @description
+ */
+int utc_nfc_se_unset_preferred_handler_n(void)
+{
+    int ret;
+
+    nfc_manager_deinitialize();
+    ret = nfc_se_unset_preferred_handler();
+
+         if(!nfc_supported){
+                 assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+         }else{
+                 assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+         }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_event_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_event_cb_p(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_event_cb(_utc_se_event_cb, NULL);
+        if(!nfc_supported){
+                assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+        }else{
+                assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_event_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_event_cb_n(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_event_cb(NULL, NULL);
+
+        if(!nfc_supported){
+                assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+        } else{
+                assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_se_event_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_se_event_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_se_event_cb();
+       ret = get_last_result();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NONE);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_se_event_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_se_event_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       nfc_manager_unset_se_event_cb();
+       ret = get_last_result();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_transaction_event_cb_p1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_transaction_event_cb_p1(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_transaction_event_cb(NFC_SE_TYPE_ESE, _utc_se_transaction_event_cb, NULL);
+
+    if(!nfc_supported){
+
+        assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+    }
+    else{
+        assert_eq(ret, NFC_ERROR_NONE);
+    }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_transaction_event_cb_p2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_transaction_event_cb_p2(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_transaction_event_cb(NFC_SE_TYPE_UICC, _utc_se_transaction_event_cb, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_transaction_event_cb_n1
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_transaction_event_cb_n1(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_transaction_event_cb(NFC_SE_TYPE_UICC, NULL, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_transaction_event_cb_n2
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_transaction_event_cb_n2(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_transaction_event_cb(NFC_SE_TYPE_DISABLE, _utc_se_transaction_event_cb, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_set_se_transaction_event_cb_n3
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_set_se_transaction_event_cb_n3(void)
+{
+    int ret;
+
+    ret = nfc_manager_set_se_transaction_event_cb(-1, _utc_se_transaction_event_cb, NULL);
+
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_INVALID_PARAMETER);
+        }
+
+    return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_se_transaction_event_cb_p
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_se_transaction_event_cb_p(void)
+{
+       int ret;
+
+       nfc_manager_unset_se_transaction_event_cb(NFC_SE_TYPE_ESE);
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NONE);
+        }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_unset_se_transaction_event_cb_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_unset_se_transaction_event_cb_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+
+       nfc_manager_unset_se_transaction_event_cb(NFC_SE_TYPE_ESE);
+
+       ret = get_last_result();
+       if(!nfc_supported){
+
+            assert_eq(ret,NFC_ERROR_NOT_SUPPORTED);
+        }
+        else{
+            assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+        }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_enable_transaction_fg_dispatch_p
+ * @since_tizen                2.3
+ * @remarks             This API can return a security error depending on the security level of the manufacturer.
+ *                      If you want to know about security level in detail, See the GSMA specification.\n
+ *                      (http://www.gsma.com/digitalcommerce/wp-content/uploads/2013/12/GSMA-NFC05-NFC-Handset-APIs-Requirement-Specification-version-4-1.pdf)
+ * @description
+ */
+int utc_nfc_manager_enable_transaction_fg_dispatch_p(void)
+{
+       int ret;
+
+       ret = nfc_manager_enable_transaction_fg_dispatch();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert(ret == NFC_ERROR_NONE
+                       || ret == NFC_ERROR_ILLEGAL_STATE
+                       || ret == NFC_ERROR_SECURITY_RESTRICTED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_enable_transaction_fg_dispatch_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_enable_transaction_fg_dispatch_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       ret = nfc_manager_enable_transaction_fg_dispatch();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_disable_transaction_fg_dispatch_p
+ * @since_tizen                2.3
+ * @remarks             This API can return a security error depending on the security level of the manufacturer.
+ *                      If you want to know about security level in detail, See the GSMA specification.\n
+ *                      (http://www.gsma.com/digitalcommerce/wp-content/uploads/2013/12/GSMA-NFC05-NFC-Handset-APIs-Requirement-Specification-version-4-1.pdf)
+ * @description
+ */
+int utc_nfc_manager_disable_transaction_fg_dispatch_p(void)
+{
+       int ret;
+
+       ret = nfc_manager_disable_transaction_fg_dispatch();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+               assert(ret == NFC_ERROR_NONE
+                       || ret == NFC_ERROR_SECURITY_RESTRICTED);
+       }
+
+       return 0;
+}
+
+/**
+ * @testcase           utc_nfc_manager_disable_transaction_fg_dispatch_n
+ * @since_tizen                2.3
+ * @description
+ */
+int utc_nfc_manager_disable_transaction_fg_dispatch_n(void)
+{
+       int ret;
+
+       nfc_manager_deinitialize();
+       ret = nfc_manager_disable_transaction_fg_dispatch();
+
+       if(!nfc_supported){
+               assert_eq(ret, NFC_ERROR_NOT_SUPPORTED);
+       }else{
+          assert_eq(ret, NFC_ERROR_NOT_INITIALIZED);
+       }
+
+       return 0;
+}