apply coding rule

Signed-off-by: Ji-hoon Jung <jh8801.jung@samsung.com>
Change-Id: I2b155a5655a84777ff4f0be23a063fd69721ba11

diff --git a/src/nfc_card_emulation.c b/src/nfc_card_emulation.c
index fdb7891..4681fdd 100644 (file)
--- a/src/nfc_card_emulation.c
+++ b/src/nfc_card_emulation.c
@@ -30,13 +30,12 @@ int nfc_se_open_secure_element_internal(
        CHECK_INIT();
        CHECK_INVALID(handle == NULL);
 
-       switch (se_type)
-       {
-       case NFC_SE_TYPE_ESE :
+       switch (se_type) {
+       case NFC_SE_TYPE_ESE:
                type = NET_NFC_SE_TYPE_ESE;
                break;
 
-       case NFC_SE_TYPE_UICC :
+       case NFC_SE_TYPE_UICC:
                type = NET_NFC_SE_TYPE_UICC;
                break;
 
@@ -48,9 +47,8 @@ int nfc_se_open_secure_element_internal(
        result = net_nfc_client_se_open_internal_secure_element_sync(
                type,
                &temp);
-       if (result == NET_NFC_OK) {
+       if (result == NET_NFC_OK)
                *handle = (nfc_se_h)temp;
-       }
 
        return nfc_common_convert_error_code(__func__, result);
 }
@@ -222,13 +220,12 @@ int nfc_se_get_card_emulation_mode(nfc_se_card_emulation_mode_type_e *mode)
 
        result = net_nfc_get_card_emulation_mode_sync(&se_mode);
 
-       switch(se_mode)
-       {
-       case NET_NFC_CARD_EMELATION_ENABLE :
+       switch (se_mode) {
+       case NET_NFC_CARD_EMELATION_ENABLE:
                *mode = NFC_SE_CARD_EMULATION_MODE_ON;
                break;
 
-       case NET_NFC_CARD_EMULATION_DISABLE :
+       case NET_NFC_CARD_EMULATION_DISABLE:
                *mode = NFC_SE_CARD_EMULATION_MODE_OFF;
                break;
        }
@@ -252,8 +249,7 @@ int nfc_hce_send_apdu_response(nfc_se_h handle, unsigned char *resp, unsigned in
        if (result == NET_NFC_OK) {
                result = net_nfc_client_hce_response_apdu_sync(handle, data);
                net_nfc_free_data(data);
-       }
-       else {
+       } else {
                LOG_ERR("net_nfc_create_data failed, [%d]", result);
        }
 

diff --git a/src/nfc_common.c b/src/nfc_common.c
index 0dfe109..4e6d79d 100644 (file)
--- a/src/nfc_common.c
+++ b/src/nfc_common.c
@@ -36,16 +36,14 @@ char * nfc_common_get_bt_address_string(data_h data)
        uint8_t *buffer;
        uint32_t length;
 
-       if (data == NULL) {
+       if (data == NULL)
                return NULL;
-       }
 
        buffer = net_nfc_get_data_buffer(data);
        length = net_nfc_get_data_length(data);
 
-       if (buffer == NULL || length < 6) {
+       if (buffer == NULL || length < 6)
                return NULL;
-       }
 
        return g_strdup_printf("%02X:%02X:%02X:%02X:%02X:%02X",
                buffer[0],
@@ -74,106 +72,105 @@ int nfc_common_convert_error_code(const char *func, int native_error_code)
        int error_code = NFC_ERROR_NONE;
        char *errorstr = NULL;
 
-       switch (native_error_code)
-       {
-               case NET_NFC_OK:
-                       error_code = NFC_ERROR_NONE;
-                       errorstr = "ERROR_NONE";
-                       break;
-
-               case NET_NFC_ALLOC_FAIL:
-                       error_code = NFC_ERROR_OUT_OF_MEMORY;
-                       errorstr = "OUT_OF_MEMORY";
-                       break;
-
-               case NET_NFC_NOT_CONNECTED:
-                       error_code = NFC_ERROR_NO_DEVICE;
-                       errorstr = "NO_DEVICE";
-                       break;
-
-               case NET_NFC_UNKNOWN_ERROR:
-               case NET_NFC_THREAD_CREATE_FAIL:
-               case NET_NFC_IPC_FAIL:
-               case NET_NFC_BUFFER_TOO_SMALL:
-               case NET_NFC_COMMUNICATE_WITH_CONTROLLER_FAILED:
-               case NET_NFC_RF_ERROR:
-               case NET_NFC_NOT_SUPPORTED:
-               case NET_NFC_TAG_READ_FAILED:
-               case NET_NFC_TAG_WRITE_FAILED:
-               case NET_NFC_OPERATION_FAIL:
-               case NET_NFC_INSUFFICIENT_STORAGE:
-               case NET_NFC_NOT_INITIALIZED:
-               case NET_NFC_NOT_REGISTERED:
-                       error_code = NFC_ERROR_OPERATION_FAILED;
-                       errorstr = "OPERATION_FAILED";
-                       break;
-
-               case NET_NFC_SECURITY_FAIL:
-                       error_code = NFC_ERROR_SECURITY_RESTRICTED;
-                       errorstr = "SECURITY_RESTRICTED";
-                       break;
-
-               case NET_NFC_INVALID_STATE:
-                       error_code = NFC_ERROR_ILLEGAL_STATE;
-                       errorstr = "ILLEGAL_STATE";
-                       break;
-
-               case NET_NFC_OUT_OF_BOUND:
-               case NET_NFC_NULL_PARAMETER:
-               case NET_NFC_NOT_ALLOWED_OPERATION:
-               case NET_NFC_LLCP_INVALID_SOCKET:
-               case NET_NFC_NO_DATA_FOUND:
-                       error_code = NFC_ERROR_INVALID_PARAMETER;
-                       errorstr = "INVALID_PARAMETER";
-                       break;
-               case NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE:
-                       error_code = NFC_ERROR_INVALID_RECORD_TYPE;
-                       errorstr = "INVALID_RECORD_TYPE";
-                       break;
-
-               case NET_NFC_ALREADY_INITIALIZED:
-               case NET_NFC_ALREADY_REGISTERED:
-                       error_code = NFC_ERROR_NONE;
-                       errorstr = "ERROR_NONE";
-                       break;
-
-               case NET_NFC_RF_TIMEOUT:
-                       error_code = NFC_ERROR_TIMED_OUT;
-                       errorstr = "TIMED_OUT";
-                       break;
-               case NET_NFC_INVALID_FORMAT:
-               case NET_NFC_NDEF_TYPE_LENGTH_IS_NOT_OK:
-               case NET_NFC_NDEF_ID_LENGTH_IS_NOT_OK:
-               case NET_NFC_NDEF_BUF_END_WITHOUT_ME:
-                       error_code = NFC_ERROR_INVALID_NDEF_MESSAGE;
-                       errorstr = "INVALID_NDEF_MESSAGE";
-                       break;
-               case NET_NFC_NO_NDEF_MESSAGE:
-                       error_code = NFC_ERROR_NO_NDEF_MESSAGE;
-                       errorstr = "NO_NDEF_MESSAGE";
-                       break;
-               case NET_NFC_BUSY :
-                       error_code = NFC_ERROR_DEVICE_BUSY;
-                       errorstr = "DEVICE_BUSY";
-                       break;
-               case NET_NFC_NO_NDEF_SUPPORT:
-                       error_code = NFC_ERROR_NOT_NDEF_FORMAT;
-                       errorstr = "NOT_SUPPORTED";
-                       break;
-               case NET_NFC_PERMISSION_DENIED:
-                       error_code = NFC_ERROR_PERMISSION_DENIED;
-                       errorstr = "PERMISSION_DENIED";
-                       break;
-               case NET_NFC_NOT_ACTIVATED:
-                       error_code = NFC_ERROR_NOT_ACTIVATED;
-                       errorstr = "NOT_ACTIVATED";
-                       break;
-               default :
-                       error_code = NFC_ERROR_OPERATION_FAILED;
-                       errorstr = "OPERATION_FAILED";
+       switch (native_error_code) {
+       case NET_NFC_OK:
+               error_code = NFC_ERROR_NONE;
+               errorstr = "ERROR_NONE";
+               break;
+
+       case NET_NFC_ALLOC_FAIL:
+               error_code = NFC_ERROR_OUT_OF_MEMORY;
+               errorstr = "OUT_OF_MEMORY";
+               break;
+
+       case NET_NFC_NOT_CONNECTED:
+               error_code = NFC_ERROR_NO_DEVICE;
+               errorstr = "NO_DEVICE";
+               break;
+
+       case NET_NFC_UNKNOWN_ERROR:
+       case NET_NFC_THREAD_CREATE_FAIL:
+       case NET_NFC_IPC_FAIL:
+       case NET_NFC_BUFFER_TOO_SMALL:
+       case NET_NFC_COMMUNICATE_WITH_CONTROLLER_FAILED:
+       case NET_NFC_RF_ERROR:
+       case NET_NFC_NOT_SUPPORTED:
+       case NET_NFC_TAG_READ_FAILED:
+       case NET_NFC_TAG_WRITE_FAILED:
+       case NET_NFC_OPERATION_FAIL:
+       case NET_NFC_INSUFFICIENT_STORAGE:
+       case NET_NFC_NOT_INITIALIZED:
+       case NET_NFC_NOT_REGISTERED:
+               error_code = NFC_ERROR_OPERATION_FAILED;
+               errorstr = "OPERATION_FAILED";
+               break;
+
+       case NET_NFC_SECURITY_FAIL:
+               error_code = NFC_ERROR_SECURITY_RESTRICTED;
+               errorstr = "SECURITY_RESTRICTED";
+               break;
+
+       case NET_NFC_INVALID_STATE:
+               error_code = NFC_ERROR_ILLEGAL_STATE;
+               errorstr = "ILLEGAL_STATE";
+               break;
+
+       case NET_NFC_OUT_OF_BOUND:
+       case NET_NFC_NULL_PARAMETER:
+       case NET_NFC_NOT_ALLOWED_OPERATION:
+       case NET_NFC_LLCP_INVALID_SOCKET:
+       case NET_NFC_NO_DATA_FOUND:
+               error_code = NFC_ERROR_INVALID_PARAMETER;
+               errorstr = "INVALID_PARAMETER";
+               break;
+       case NET_NFC_NDEF_RECORD_IS_NOT_EXPECTED_TYPE:
+               error_code = NFC_ERROR_INVALID_RECORD_TYPE;
+               errorstr = "INVALID_RECORD_TYPE";
+               break;
+
+       case NET_NFC_ALREADY_INITIALIZED:
+       case NET_NFC_ALREADY_REGISTERED:
+               error_code = NFC_ERROR_NONE;
+               errorstr = "ERROR_NONE";
+               break;
+
+       case NET_NFC_RF_TIMEOUT:
+               error_code = NFC_ERROR_TIMED_OUT;
+               errorstr = "TIMED_OUT";
+               break;
+       case NET_NFC_INVALID_FORMAT:
+       case NET_NFC_NDEF_TYPE_LENGTH_IS_NOT_OK:
+       case NET_NFC_NDEF_ID_LENGTH_IS_NOT_OK:
+       case NET_NFC_NDEF_BUF_END_WITHOUT_ME:
+               error_code = NFC_ERROR_INVALID_NDEF_MESSAGE;
+               errorstr = "INVALID_NDEF_MESSAGE";
+               break;
+       case NET_NFC_NO_NDEF_MESSAGE:
+               error_code = NFC_ERROR_NO_NDEF_MESSAGE;
+               errorstr = "NO_NDEF_MESSAGE";
+               break;
+       case NET_NFC_BUSY:
+               error_code = NFC_ERROR_DEVICE_BUSY;
+               errorstr = "DEVICE_BUSY";
+               break;
+       case NET_NFC_NO_NDEF_SUPPORT:
+               error_code = NFC_ERROR_NOT_NDEF_FORMAT;
+               errorstr = "NOT_SUPPORTED";
+               break;
+       case NET_NFC_PERMISSION_DENIED:
+               error_code = NFC_ERROR_PERMISSION_DENIED;
+               errorstr = "PERMISSION_DENIED";
+               break;
+       case NET_NFC_NOT_ACTIVATED:
+               error_code = NFC_ERROR_NOT_ACTIVATED;
+               errorstr = "NOT_ACTIVATED";
+               break;
+       default:
+               error_code = NFC_ERROR_OPERATION_FAILED;
+               errorstr = "OPERATION_FAILED";
        }
 
-       if ( error_code != NFC_ERROR_NONE )
+       if (error_code != NFC_ERROR_NONE)
                LOGE("NFC func : %s, %s(0x%08x)", func, errorstr, error_code);
 
        return error_code;
@@ -191,7 +188,7 @@ bool nfc_common_is_supported(char *str)
 
        ret = system_info_get_platform_bool(str, &is_supported);
 
-       if(ret != 0)
+       if (ret != 0)
                return false;
 
        return is_supported;

diff --git a/src/nfc_manager.c b/src/nfc_manager.c
index 760a31c..e90461d 100644 (file)
--- a/src/nfc_manager.c
+++ b/src/nfc_manager.c
@@ -24,7 +24,7 @@ bool nfc_manager_is_supported(void)
 
        nfc_supported = nfc_common_is_supported(NFC_FEATURE);
 
-       if(nfc_supported == true)
+       if (nfc_supported == true)
                set_last_result(NFC_ERROR_NONE);
        else
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
@@ -39,7 +39,7 @@ static void _activation_changed_cb(net_nfc_error_e result, void *user_data)
 
        LOG_BEGIN();
 
-       if(user_data == NULL) {
+       if (user_data == NULL) {
                LOG_ERR("user_data is NULL");
                return;
        }
@@ -49,9 +49,8 @@ static void _activation_changed_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -67,38 +66,27 @@ int nfc_manager_set_activation(bool activation,
        CHECK_SUPPORTED(NFC_FEATURE);
        CHECK_INIT();
 
-       if(nfc_manager_is_activated() == activation)
-       {
+       if (nfc_manager_is_activated() == activation) {
                if (activation)
-               {
                        ret = NFC_ERROR_ALREADY_ACTIVATED;
-               }
                else
-               {
                        ret = NFC_ERROR_ALREADY_DEACTIVATED;
-               }
-       }
-       else
-       {
+       } else {
                GVariant *parameter;
 
                parameter = g_variant_new("(uu)",
                        callback,
                        user_data);
-               if (parameter != NULL)
-               {
+               if (parameter != NULL) {
                        ret = net_nfc_client_manager_set_active(activation,
                                _activation_changed_cb,
                                parameter);
-                       if (ret != NET_NFC_OK)
-                       {
+                       if (ret != NET_NFC_OK) {
                                LOG_ERR("net_nfc_client_manager_set_active fail");
 
                                g_variant_unref(parameter);
                        }
-               }
-               else
-               {
+               } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
 
@@ -115,15 +103,14 @@ bool nfc_manager_is_activated(void)
 
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_FEATURE) == false) {
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return false;
        }
 
        ret = net_nfc_client_get_nfc_state(&activated);
 
-       set_last_result(nfc_common_convert_error_code(__func__,ret));
+       set_last_result(nfc_common_convert_error_code(__func__, ret));
 
        return (!!activated);
 }
@@ -146,15 +133,13 @@ void nfc_manager_unset_activation_changed_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
@@ -173,8 +158,7 @@ int nfc_manager_initialize(void)
 
        CHECK_SUPPORTED(NFC_FEATURE);
 
-       if(!nfc_common_is_initialized())
-       {
+       if (!nfc_common_is_initialized()) {
                ret = net_nfc_client_initialize();
                if (ret != NET_NFC_OK)
                        return nfc_common_convert_error_code(__func__, ret);
@@ -187,7 +171,7 @@ int nfc_manager_initialize(void)
        return nfc_common_convert_error_code(__func__, ret);
 }
 
-int nfc_manager_deinitialize (void)
+int nfc_manager_deinitialize(void)
 {
        int ret = NET_NFC_OK;
 
@@ -195,8 +179,7 @@ int nfc_manager_deinitialize (void)
 
        CHECK_SUPPORTED(NFC_FEATURE);
 
-       if(nfc_common_is_initialized())
-       {
+       if (nfc_common_is_initialized()) {
                net_nfc_client_se_unset_event_cb();
 
                net_nfc_client_p2p_unset_device_discovered();
@@ -219,7 +202,7 @@ static void _tag_discovered_cb(net_nfc_target_info_h info, void *user_data)
 
        gdbus_nfc_context.current_tag = info;
 
-       if(gdbus_nfc_context.on_tag_discovered_cb != NULL) {
+       if (gdbus_nfc_context.on_tag_discovered_cb != NULL) {
                gdbus_nfc_context.on_tag_discovered_cb(
                        NFC_DISCOVERED_TYPE_ATTACHED,
                        (nfc_tag_h)gdbus_nfc_context.current_tag,
@@ -227,8 +210,7 @@ static void _tag_discovered_cb(net_nfc_target_info_h info, void *user_data)
        }
 
        /* ndef discovered cb */
-       if(gdbus_nfc_context.on_ndef_discovered_cb)
-       {
+       if (gdbus_nfc_context.on_ndef_discovered_cb) {
                ndef_message_h ndef_message = NULL;
 
                if (net_nfc_get_tag_ndef_message((net_nfc_target_info_h)info,
@@ -245,7 +227,7 @@ static void _tag_detached_cb(void *user_data)
 {
        LOG_BEGIN();
 
-       if(gdbus_nfc_context.on_tag_discovered_cb != NULL) {
+       if (gdbus_nfc_context.on_tag_discovered_cb != NULL) {
                gdbus_nfc_context.on_tag_discovered_cb(
                        NFC_DISCOVERED_TYPE_DETACHED,
                        (nfc_tag_h)gdbus_nfc_context.current_tag,
@@ -274,19 +256,17 @@ int nfc_manager_set_ndef_discovered_cb(
        return NFC_ERROR_NONE;
 }
 
-void nfc_manager_unset_ndef_discovered_cb( void )
+void nfc_manager_unset_ndef_discovered_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
@@ -302,22 +282,19 @@ void nfc_manager_set_tag_filter(int filter)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_TAG_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_TAG_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
        }
 
-       if(filter < NET_NFC_ALL_DISABLE)
-       {
+       if (filter < NET_NFC_ALL_DISABLE) {
                LOG_ERR("Invalid parameter");
                set_last_result(NFC_ERROR_INVALID_PARAMETER);
                return;
@@ -332,15 +309,13 @@ int nfc_manager_get_tag_filter(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_TAG_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_TAG_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return 0;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return 0;
@@ -368,11 +343,10 @@ int nfc_manager_get_connected_tag(nfc_tag_h *tag)
        net_nfc_client_tag_set_tag_detached(_tag_detached_cb, NULL);
 
 
-       if(gdbus_nfc_context.current_tag == NULL) {
+       if (gdbus_nfc_context.current_tag == NULL) {
                ret = net_nfc_client_tag_get_current_tag_info_sync(&result);
-               if (ret == NET_NFC_OK) {
+               if (ret == NET_NFC_OK)
                        *tag = (nfc_tag_h)result;
-               }
        } else {
                /* FIXME ??? */
                *tag = gdbus_nfc_context.current_tag;
@@ -399,7 +373,7 @@ int nfc_manager_get_connected_target(nfc_p2p_target_h *target)
        net_nfc_client_tag_set_tag_discovered(_tag_discovered_cb, NULL);
        net_nfc_client_tag_set_tag_detached(_tag_detached_cb, NULL);
 
-       if(gdbus_nfc_context.current_target == NULL) {
+       if (gdbus_nfc_context.current_target == NULL) {
                ret = net_nfc_client_tag_get_current_target_handle_sync(&result);
                if (ret == NET_NFC_OK) {
                        gdbus_nfc_context.current_target = result;
@@ -438,15 +412,13 @@ void nfc_manager_unset_tag_discovered_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_TAG_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_TAG_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
@@ -466,7 +438,7 @@ static void _p2p_discovered_cb(
 
        gdbus_nfc_context.current_target = handle_info;
 
-       if(gdbus_nfc_context.on_p2p_target_discovered_cb != NULL) {
+       if (gdbus_nfc_context.on_p2p_target_discovered_cb != NULL) {
                gdbus_nfc_context.on_p2p_target_discovered_cb(
                        NFC_DISCOVERED_TYPE_ATTACHED,
                        (nfc_p2p_target_h)gdbus_nfc_context.current_target,
@@ -481,7 +453,7 @@ static void _p2p_detached_cb(void *user_data)
 
        LOG_BEGIN();
 
-       if(gdbus_nfc_context.on_p2p_target_discovered_cb != NULL) {
+       if (gdbus_nfc_context.on_p2p_target_discovered_cb != NULL) {
                gdbus_nfc_context.on_p2p_target_discovered_cb(
                        NFC_DISCOVERED_TYPE_DETACHED,
                        handle,
@@ -517,15 +489,13 @@ void nfc_manager_unset_p2p_target_discovered_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_P2P_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_P2P_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
@@ -547,11 +517,10 @@ int nfc_manager_set_system_handler_enable(bool enable)
        CHECK_SUPPORTED(NFC_FEATURE);
        CHECK_INIT();
 
-       if (enable == true) {
+       if (enable == true)
                state = 0;
-       } else {
+       else
                state = 1;
-       }
 
        ret = net_nfc_client_sys_handler_set_launch_popup_state(state);
 
@@ -568,11 +537,10 @@ int nfc_manager_set_system_handler_enable_force(bool enable)
        CHECK_SUPPORTED(NFC_FEATURE);
        CHECK_INIT();
 
-       if (enable == true) {
+       if (enable == true)
                state = 0;
-       } else {
+       else
                state = 1;
-       }
 
        ret = net_nfc_client_sys_handler_set_launch_popup_state_force(state);
 
@@ -586,15 +554,13 @@ bool nfc_manager_is_system_handler_enabled(void)
 
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return false;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return false;
@@ -602,7 +568,7 @@ bool nfc_manager_is_system_handler_enabled(void)
 
        ret = net_nfc_client_sys_handler_get_launch_popup_state(&state);
 
-       set_last_result(nfc_common_convert_error_code(__func__,ret));
+       set_last_result(nfc_common_convert_error_code(__func__, ret));
 
        return (state == 0);
 }
@@ -627,16 +593,16 @@ static void _se_event_cb(net_nfc_message_e message, void *user_data)
        LOG_BEGIN();
 
        if (gdbus_nfc_context.on_se_event_cb != NULL) {
-               if(message == NET_NFC_MESSAGE_SE_CARD_EMULATION_CHANGED)
+               if (message == NET_NFC_MESSAGE_SE_CARD_EMULATION_CHANGED)
                        gdbus_nfc_context.on_se_event_cb(
                                NFC_SE_EVENT_CARD_EMULATION_CHANGED,
                                gdbus_nfc_context.on_se_event_user_data);
 
-               else if(message == NET_NFC_MESSAGE_SE_TYPE_CHANGED)
+               else if (message == NET_NFC_MESSAGE_SE_TYPE_CHANGED)
                        gdbus_nfc_context.on_se_event_cb(
                                NFC_SE_EVENT_SE_TYPE_CHANGED,
                                gdbus_nfc_context.on_se_event_user_data);
-               else if(message == NET_NFC_MESSAGE_SE_FIELD_ON)
+               else if (message == NET_NFC_MESSAGE_SE_FIELD_ON)
                        gdbus_nfc_context.on_se_event_cb(
                                NFC_SE_EVENT_FIELD_ON,
                                gdbus_nfc_context.on_se_event_user_data);
@@ -663,15 +629,13 @@ void nfc_manager_unset_se_event_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_CE_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_CE_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
@@ -715,22 +679,20 @@ int nfc_manager_set_se_transaction_event_cb(
        gdbus_nfc_context.on_se_transaction_event_cb = callback;
        gdbus_nfc_context.on_se_transaction_event_user_data = user_data;
 
-       switch(se_type)
-       {
-               case NFC_SE_TYPE_ESE:
-                       type = NET_NFC_SE_TYPE_ESE;
-                       break;
-
-               case NFC_SE_TYPE_UICC:
-                       type = NET_NFC_SE_TYPE_UICC;
-                       break;
-               case NET_NFC_SE_TYPE_HCE:
-                       type = NET_NFC_SE_TYPE_HCE;
-                       break;
-               default:
-                       return NFC_ERROR_INVALID_PARAMETER;
-                       break;
+       switch (se_type) {
+       case NFC_SE_TYPE_ESE:
+               type = NET_NFC_SE_TYPE_ESE;
+               break;
 
+       case NFC_SE_TYPE_UICC:
+               type = NET_NFC_SE_TYPE_UICC;
+               break;
+       case NET_NFC_SE_TYPE_HCE:
+               type = NET_NFC_SE_TYPE_HCE;
+               break;
+       default:
+               return NFC_ERROR_INVALID_PARAMETER;
+               break;
        }
 
        net_nfc_client_se_set_transaction_event_cb(type, _se_transaction_event_cb, user_data);
@@ -744,32 +706,29 @@ void nfc_manager_unset_se_transaction_event_cb(nfc_se_type_e se_type)
 
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_CE_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_CE_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;
        }
 
-       switch(se_type)
-       {
-               case NFC_SE_TYPE_ESE:
-                       type = NET_NFC_SE_TYPE_ESE;
-                       break;
+       switch (se_type) {
+       case NFC_SE_TYPE_ESE:
+               type = NET_NFC_SE_TYPE_ESE;
+               break;
 
-               case NFC_SE_TYPE_UICC:
-                       type = NET_NFC_SE_TYPE_UICC;
-                       break;
-               default:
-                       type = NET_NFC_SE_TYPE_NONE;
-                       break;
+       case NFC_SE_TYPE_UICC:
+               type = NET_NFC_SE_TYPE_UICC;
+               break;
+       default:
+               type = NET_NFC_SE_TYPE_NONE;
+               break;
        }
 
        net_nfc_client_se_unset_transaction_event_cb(type);
@@ -815,18 +774,17 @@ int nfc_manager_set_se_type(nfc_se_type_e type)
        CHECK_INVALID(type < NFC_SE_TYPE_DISABLE);
        CHECK_INVALID(type > NFC_SE_TYPE_HCE);
 
-       switch (type)
-       {
-       case NFC_SE_TYPE_ESE :
+       switch (type) {
+       case NFC_SE_TYPE_ESE:
                se_type = NET_NFC_SE_TYPE_ESE;
                break;
-       case NFC_SE_TYPE_UICC :
+       case NFC_SE_TYPE_UICC:
                se_type = NET_NFC_SE_TYPE_UICC;
                break;
-       case NFC_SE_TYPE_HCE :
+       case NFC_SE_TYPE_HCE:
                se_type = NET_NFC_SE_TYPE_HCE;
                break;
-       default :
+       default:
                se_type = NET_NFC_SE_TYPE_NONE;
                break;
        }
@@ -849,20 +807,19 @@ int nfc_manager_get_se_type(nfc_se_type_e *type)
 
        ret = net_nfc_client_se_get_secure_element_type_sync(&se_type);
 
-       switch (se_type)
-       {
-               case NET_NFC_SE_TYPE_ESE :
-                       *type = NFC_SE_TYPE_ESE;
-                       break;
-               case NET_NFC_SE_TYPE_UICC :
-                       *type = NFC_SE_TYPE_UICC;
-                       break;
-               case NET_NFC_SE_TYPE_HCE :
-                       *type = NFC_SE_TYPE_HCE;
-                       break;
-               default:
-                       *type = NFC_SE_TYPE_DISABLE;
-                       break;
+       switch (se_type) {
+       case NET_NFC_SE_TYPE_ESE:
+               *type = NFC_SE_TYPE_ESE;
+               break;
+       case NET_NFC_SE_TYPE_UICC:
+               *type = NFC_SE_TYPE_UICC;
+               break;
+       case NET_NFC_SE_TYPE_HCE:
+               *type = NFC_SE_TYPE_HCE;
+               break;
+       default:
+               *type = NFC_SE_TYPE_DISABLE;
+               break;
        }
 
        return nfc_common_convert_error_code(__func__, ret);
@@ -904,15 +861,13 @@ void nfc_manager_unset_hce_event_cb(void)
 {
        LOG_BEGIN();
 
-       if(nfc_common_is_supported(NFC_CE_HCE_FEATURE) == false)
-       {
+       if (nfc_common_is_supported(NFC_CE_HCE_FEATURE) == false) {
                LOG_ERR("NFC not supported");
                set_last_result(NFC_ERROR_NOT_SUPPORTED);
                return;
        }
 
-       if(nfc_common_is_initialized() == false)
-       {
+       if (nfc_common_is_initialized() == false) {
                LOG_ERR("NFC not initialized");
                set_last_result(NFC_ERROR_NOT_INITIALIZED);
                return;

diff --git a/src/nfc_ndef.c b/src/nfc_ndef.c
index 446f386..c6ede9c 100644 (file)
--- a/src/nfc_ndef.c
+++ b/src/nfc_ndef.c
@@ -38,13 +38,11 @@ int nfc_ndef_record_create(nfc_ndef_record_h *record,
 
        net_nfc_create_data(&type_data, type, type_size);
 
-       if (id != NULL && id_size > 0) {
+       if (id != NULL && id_size > 0)
                net_nfc_create_data(&id_data, id, id_size);
-       }
 
-       if (payload != NULL && payload_size > 0) {
+       if (payload != NULL && payload_size > 0)
                net_nfc_create_data(&payload_data, payload, payload_size);
-       }
 
        ret = net_nfc_create_record(
                (ndef_record_h *)record,
@@ -53,13 +51,11 @@ int nfc_ndef_record_create(nfc_ndef_record_h *record,
                id_data,
                payload_data);
 
-       if (payload_data != NULL) {
+       if (payload_data != NULL)
                net_nfc_free_data(payload_data);
-       }
 
-       if (id_data != NULL) {
+       if (id_data != NULL)
                net_nfc_free_data(id_data);
-       }
 
        net_nfc_free_data(type_data);
 
@@ -155,19 +151,17 @@ int nfc_ndef_record_get_mime_type(nfc_ndef_record_h record,
        CHECK_INVALID(mime_type == NULL);
 
        if (nfc_ndef_record_get_tnf(record, &tnf) != NET_NFC_OK ||
-               tnf != NFC_RECORD_TNF_MIME_MEDIA)
-                       {
+               tnf != NFC_RECORD_TNF_MIME_MEDIA) {
                return NFC_ERROR_INVALID_RECORD_TYPE;
        }
 
        ret = nfc_ndef_record_get_type(record, &typename, &length);
        if (ret == NET_NFC_OK) {
                *mime_type = calloc(1, length + 1);
-               if (*mime_type != NULL) {
+               if (*mime_type != NULL)
                        memcpy(*mime_type, typename, length);
-               } else {
+               else
                        ret = NET_NFC_ALLOC_FAIL;
-               }
        }
 
        return nfc_common_convert_error_code(__func__, ret);
@@ -336,13 +330,10 @@ int nfc_ndef_record_get_text(nfc_ndef_record_h record, char **buffer)
        ret = nfc_ndef_record_get_type(record, &record_type, &type_size);
 
        if (ret == NFC_ERROR_NONE && record_type != NULL && type_size != 0 &&
-                               !strcmp((char*)record_type, "T"))
-       {
+                               !strcmp((char*)record_type, "T")) {
                LOG_ERR("record type is T");
                ret = net_nfc_create_text_string_from_text_record(record, buffer);
-       }
-       else
-       {
+       } else {
                LOG_ERR("record type is not T");
                return NFC_ERROR_INVALID_RECORD_TYPE;
        }

diff --git a/src/nfc_p2p.c b/src/nfc_p2p.c
index 656b957..eccde2a 100644 (file)
--- a/src/nfc_p2p.c
+++ b/src/nfc_p2p.c
@@ -23,18 +23,16 @@ static void _p2p_send_cb(net_nfc_error_e result, void *user_data)
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_data == NULL)
                return;
-       }
 
        g_variant_get((GVariant *)user_data,
                "(uu)",
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -66,9 +64,8 @@ int nfc_p2p_send(nfc_p2p_target_h target,
                        rawdata,
                        _p2p_send_cb,
                        parameter);
-               if (ret != NET_NFC_OK) {
+               if (ret != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
 
                net_nfc_free_data(rawdata);
        } else {
@@ -107,9 +104,8 @@ int nfc_p2p_send_no_permission(
                        rawdata,
                        _p2p_send_cb,
                        parameter);
-               if (ret != NET_NFC_OK) {
+               if (ret != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
 
                net_nfc_free_data(rawdata);
        } else {
@@ -123,8 +119,7 @@ static void _p2p_set_data_received_cb(data_h data, void *user_data)
 {
        LOG_BEGIN();
 
-       if (gdbus_nfc_context.on_p2p_recv_cb != NULL)
-       {
+       if (gdbus_nfc_context.on_p2p_recv_cb != NULL) {
                ndef_message_h ndef_message;
 
                net_nfc_create_ndef_message_from_rawdata(&ndef_message, data);
@@ -201,28 +196,28 @@ static void _snep_start_server_cb(
                nfc_snep_event_e snep_event;
 
                switch ((int)event) {
-               case NET_NFC_SNEP_GET :
+               case NET_NFC_SNEP_GET:
                        snep_event = NFC_SNEP_EVENT_GET;
                        break;
 
-               case NET_NFC_SNEP_PUT :
+               case NET_NFC_SNEP_PUT:
                        snep_event = NFC_SNEP_EVENT_PUT;
                        break;
 
-               case NET_NFC_LLCP_REGISTERED :
+               case NET_NFC_LLCP_REGISTERED:
                        snep_event = NFC_SNEP_EVENT_REGISTER;
                        break;
 
-               case NET_NFC_LLCP_UNREGISTERED :
+               case NET_NFC_LLCP_UNREGISTERED:
                        snep_event = NFC_SNEP_EVENT_UNREGISTER;
                        break;
 
-               case NET_NFC_LLCP_START :
+               case NET_NFC_LLCP_START:
                        snep_event = NFC_SNEP_EVENT_START;
                        break;
 
-               case NET_NFC_LLCP_STOP :
-               default :
+               case NET_NFC_LLCP_STOP:
+               default:
                        snep_event = NFC_SNEP_EVENT_STOP;
                        break;
                }
@@ -231,9 +226,8 @@ static void _snep_start_server_cb(
                        nfc_common_convert_error_code(__func__, result),
                        msg, user_param);
 
-               if (snep_event == NFC_SNEP_EVENT_STOP) {
+               if (snep_event == NFC_SNEP_EVENT_STOP)
                        g_variant_unref(user_data);
-               }
        }
 }
 
@@ -262,9 +256,8 @@ int nfc_snep_start_server(nfc_p2p_target_h target,
                        (sap_t)sap,
                        _snep_start_server_cb,
                        parameter);
-               if (result != NET_NFC_OK) {
+               if (result != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
        } else {
                result = NET_NFC_ALLOC_FAIL;
        }
@@ -297,28 +290,28 @@ static void _snep_start_client_cb(net_nfc_snep_handle_h arg_handle,
                nfc_snep_event_e snep_event;
 
                switch ((int)event) {
-               case NET_NFC_SNEP_GET :
+               case NET_NFC_SNEP_GET:
                        snep_event = NFC_SNEP_EVENT_GET;
                        break;
 
-               case NET_NFC_SNEP_PUT :
+               case NET_NFC_SNEP_PUT:
                        snep_event = NFC_SNEP_EVENT_PUT;
                        break;
 
-               case NET_NFC_LLCP_REGISTERED :
+               case NET_NFC_LLCP_REGISTERED:
                        snep_event = NFC_SNEP_EVENT_REGISTER;
                        break;
 
-               case NET_NFC_LLCP_UNREGISTERED :
+               case NET_NFC_LLCP_UNREGISTERED:
                        snep_event = NFC_SNEP_EVENT_UNREGISTER;
                        break;
 
-               case NET_NFC_LLCP_START :
+               case NET_NFC_LLCP_START:
                        snep_event = NFC_SNEP_EVENT_START;
                        break;
 
-               case NET_NFC_LLCP_STOP :
-               default :
+               case NET_NFC_LLCP_STOP:
+               default:
                        snep_event = NFC_SNEP_EVENT_STOP;
                        break;
                }
@@ -327,9 +320,8 @@ static void _snep_start_client_cb(net_nfc_snep_handle_h arg_handle,
                        nfc_common_convert_error_code(__func__, result),
                        msg, user_param);
 
-               if (snep_event == NFC_SNEP_EVENT_STOP) {
+               if (snep_event == NFC_SNEP_EVENT_STOP)
                        g_variant_unref(user_data);
-               }
        }
 }
 
@@ -358,9 +350,8 @@ int nfc_snep_start_client(nfc_p2p_target_h target,
                        (sap_t)sap,
                        _snep_start_client_cb,
                        parameter);
-               if (result != NET_NFC_OK) {
+               if (result != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
        } else {
                result = NET_NFC_ALLOC_FAIL;
        }
@@ -423,9 +414,8 @@ int nfc_snep_send_client_request(nfc_p2p_snep_h handle,
                        msg,
                        _snep_send_request_cb,
                        parameter);
-               if (result != NET_NFC_OK) {
+               if (result != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
        } else {
                result = NET_NFC_ALLOC_FAIL;
        }
@@ -453,27 +443,27 @@ static void _snep_event_cb(net_nfc_snep_handle_h target, net_nfc_snep_type_t eve
 
        if (callback != NULL) {
                switch ((int)event) {
-               case NET_NFC_SNEP_GET :
+               case NET_NFC_SNEP_GET:
                        event = NFC_SNEP_EVENT_GET;
                        break;
 
-               case NET_NFC_SNEP_PUT :
+               case NET_NFC_SNEP_PUT:
                        event = NFC_SNEP_EVENT_PUT;
                        break;
 
-               case NET_NFC_LLCP_REGISTERED :
+               case NET_NFC_LLCP_REGISTERED:
                        event = NFC_SNEP_EVENT_REGISTER;
                        break;
 
-               case NET_NFC_LLCP_UNREGISTERED :
+               case NET_NFC_LLCP_UNREGISTERED:
                        event = NFC_SNEP_EVENT_UNREGISTER;
                        break;
 
-               case NET_NFC_LLCP_START :
+               case NET_NFC_LLCP_START:
                        event = NFC_SNEP_EVENT_START;
                        break;
 
-               case NET_NFC_LLCP_STOP :
+               case NET_NFC_LLCP_STOP:
                        event = NFC_SNEP_EVENT_STOP;
                        break;
                }
@@ -503,9 +493,8 @@ int nfc_snep_register_server(const char *san, int sap,
        if (parameter != NULL) {
                result = net_nfc_client_snep_register_server(san, (sap_t)sap,
                        _snep_event_cb, parameter);
-               if (result != NET_NFC_OK) {
+               if (result != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
        } else {
                result = NET_NFC_ALLOC_FAIL;
        }

diff --git a/src/nfc_p2p_handover.c b/src/nfc_p2p_handover.c
index 68e2b5a..0c5e48d 100644 (file)
--- a/src/nfc_p2p_handover.c
+++ b/src/nfc_p2p_handover.c
@@ -24,9 +24,8 @@ static void _p2p_handover_cb(net_nfc_error_e result,
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_data == NULL)
                return;
-       }
 
        g_variant_get((GVariant *)user_data,
                "(uu)",
@@ -39,28 +38,28 @@ static void _p2p_handover_cb(net_nfc_error_e result,
                int len = 0;
 
                switch (carrier) {
-               case NET_NFC_CONN_HANDOVER_CARRIER_BT :
+               case NET_NFC_CONN_HANDOVER_CARRIER_BT:
                        carrior_type = NFC_AC_TYPE_BT;
                        buffer = nfc_common_get_bt_address_string(ac_data);
-                       if(buffer != NULL)
+                       if (buffer != NULL)
                                len = strlen(buffer);
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS :
+               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS:
                        carrior_type = NFC_AC_TYPE_WIFI;
                        buffer = nfc_common_get_bt_address_string(ac_data);
-                       if(buffer != NULL)
+                       if (buffer != NULL)
                                len = strlen(buffer);
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P :
+               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P:
                        carrior_type = NFC_AC_TYPE_WIFI_DIRECT;
                        buffer = nfc_common_get_bt_address_string(ac_data);
-                       if(buffer != NULL)
+                       if (buffer != NULL)
                                len = strlen(buffer);
                        break;
 
-               default :
+               default:
                        carrior_type = NFC_AC_TYPE_UNKNOWN;
                        buffer = NULL;
                        len = 0;
@@ -71,9 +70,8 @@ static void _p2p_handover_cb(net_nfc_error_e result,
                        carrior_type, (void *)buffer,
                        len, user_param);
 
-               if (buffer != NULL) {
+               if (buffer != NULL)
                        g_free(buffer);
-               }
        }
 
        g_variant_unref((GVariant *)user_data);
@@ -97,21 +95,20 @@ int nfc_p2p_connection_handover(nfc_p2p_target_h target,
        CHECK_INVALID(type > NFC_AC_TYPE_UNKNOWN);
        CHECK_ACTIVATED();
 
-       switch (type)
-       {
-       case NFC_AC_TYPE_BT :
+       switch (type) {
+       case NFC_AC_TYPE_BT:
                net_ac_type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
                break;
 
-       case NFC_AC_TYPE_WIFI :
+       case NFC_AC_TYPE_WIFI:
                net_ac_type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS;
                break;
 
-       case NFC_AC_TYPE_WIFI_DIRECT :
+       case NFC_AC_TYPE_WIFI_DIRECT:
                net_ac_type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P;
                break;
 
-       case NFC_AC_TYPE_UNKNOWN :
+       case NFC_AC_TYPE_UNKNOWN:
                net_ac_type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
                break;
 
@@ -128,9 +125,8 @@ int nfc_p2p_connection_handover(nfc_p2p_target_h target,
                        net_ac_type,
                        _p2p_handover_cb,
                        parameter);
-               if (ret != NET_NFC_OK) {
+               if (ret != NET_NFC_OK)
                        g_variant_unref(parameter);
-               }
        } else {
                ret = NET_NFC_ALLOC_FAIL;
        }
@@ -160,22 +156,22 @@ static void _connection_handover_event_cb(
                        address = NULL;
                } else {
                        switch (carrier) {
-                       case NET_NFC_CONN_HANDOVER_CARRIER_BT :
+                       case NET_NFC_CONN_HANDOVER_CARRIER_BT:
                                type = NFC_AC_TYPE_BT;
                                address = nfc_common_get_bt_address_string(ac_data);
                                break;
 
-                       case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS :
+                       case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS:
                                type = NFC_AC_TYPE_WIFI;
                                address = nfc_common_get_bt_address_string(ac_data);
                                break;
 
-                       case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P :
+                       case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P:
                                type = NFC_AC_TYPE_WIFI_DIRECT;
                                address = nfc_common_get_bt_address_string(ac_data);
                                break;
 
-                       default :
+                       default:
                                type = NFC_AC_TYPE_UNKNOWN;
                                address = NULL;
                                break;
@@ -190,9 +186,8 @@ static void _connection_handover_event_cb(
                        message,
                        gdbus_nfc_context.on_handover_event_user_data);
 
-               if (address != NULL) {
+               if (address != NULL)
                        g_free(address);
-               }
                net_nfc_free_ndef_message(message);
        }
 
@@ -327,15 +322,15 @@ int nfc_handover_message_get_carrier_by_type(nfc_handover_message_h message, nfc
        CHECK_INVALID(carrier == NULL);
 
        switch (type) {
-       case NFC_AC_TYPE_BT :
+       case NFC_AC_TYPE_BT:
                temp = NET_NFC_CONN_HANDOVER_CARRIER_BT;
                break;
 
-       case NFC_AC_TYPE_WIFI :
+       case NFC_AC_TYPE_WIFI:
                temp = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS;
                break;
 
-       case NFC_AC_TYPE_WIFI_DIRECT :
+       case NFC_AC_TYPE_WIFI_DIRECT:
                temp = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P;
                break;
 
@@ -383,19 +378,19 @@ int nfc_handover_carrier_get_cps(nfc_handover_carrier_h carrier, nfc_ac_state_e
                (net_nfc_ch_carrier_h)carrier, &temp);
        if (result == NET_NFC_OK) {
                switch (temp) {
-               case NET_NFC_CONN_HANDOVER_CARRIER_INACTIVATE :
+               case NET_NFC_CONN_HANDOVER_CARRIER_INACTIVATE:
                        *cps = NFC_AC_STATE_INACTIVATE;
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE :
+               case NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATE:
                        *cps = NFC_AC_STATE_ACTIVATE;
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATING :
+               case NET_NFC_CONN_HANDOVER_CARRIER_ACTIVATING:
                        *cps = NFC_AC_STATE_ACTIVATING;
                        break;
 
-               default :
+               default:
                        *cps = NFC_AC_STATE_UNKNOWN;
                        break;
                }
@@ -420,19 +415,19 @@ int nfc_handover_carrier_get_type(nfc_handover_carrier_h carrier, nfc_ac_type_e
                (net_nfc_ch_carrier_h)carrier, &temp);
        if (result == NET_NFC_OK) {
                switch (temp) {
-               case NET_NFC_CONN_HANDOVER_CARRIER_BT :
+               case NET_NFC_CONN_HANDOVER_CARRIER_BT:
                        *type = NFC_AC_TYPE_BT;
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS :
+               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_WPS:
                        *type = NFC_AC_TYPE_WIFI;
                        break;
 
-               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P :
+               case NET_NFC_CONN_HANDOVER_CARRIER_WIFI_P2P:
                        *type = NFC_AC_TYPE_WIFI_DIRECT;
                        break;
 
-               default :
+               default:
                        *type = NFC_AC_TYPE_UNKNOWN;
                        break;
                }

diff --git a/src/nfc_tag.c b/src/nfc_tag.c
index ae3d7b0..8f0782c 100644 (file)
--- a/src/nfc_tag.c
+++ b/src/nfc_tag.c
@@ -77,9 +77,8 @@ int nfc_tag_format_ndef(nfc_tag_h tag,
                                        key_data,
                                        _tag_format_ndef_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -146,9 +145,8 @@ int nfc_tag_read_ndef(nfc_tag_h tag,
                                handle,
                                _tag_read_ndef_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -177,9 +175,8 @@ static void _tag_write_ndef_cb(net_nfc_error_e result,
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -207,9 +204,8 @@ int nfc_tag_write_ndef(nfc_tag_h tag,
                return nfc_common_convert_error_code(__func__, ret);;
        }
 
-       if (state == NET_NFC_NDEF_CARD_READ_ONLY) {
+       if (state == NET_NFC_NDEF_CARD_READ_ONLY)
                return NFC_ERROR_READ_ONLY_NDEF;
-       }
 
        ret = net_nfc_get_tag_max_data_size((net_nfc_target_info_h)tag, &max_len);
        if (ret != NET_NFC_OK) {
@@ -223,9 +219,8 @@ int nfc_tag_write_ndef(nfc_tag_h tag,
                return nfc_common_convert_error_code(__func__, ret);;
        }
 
-       if (max_len < byte_size) {
+       if (max_len < byte_size)
                return NFC_ERROR_NO_SPACE_ON_NDEF;
-       }
 
        ret = net_nfc_get_tag_handle((net_nfc_target_info_h)tag, &handle);
        if (ret == NET_NFC_OK) {
@@ -240,9 +235,8 @@ int nfc_tag_write_ndef(nfc_tag_h tag,
                                msg,
                                _tag_write_ndef_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -261,9 +255,8 @@ static void _tag_transceive_data_cb(net_nfc_error_e result, data_h arg_data,
 
        LOG_BEGIN();
 
-       if (user_data == NULL) {
+       if (user_data == NULL)
                return;
-       }
 
        g_variant_get((GVariant *)user_data,
                "(uu)",
@@ -322,9 +315,8 @@ int nfc_tag_transceive(nfc_tag_h tag,
                                        rawdata,
                                        _tag_transceive_data_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -423,7 +415,7 @@ int nfc_tag_foreach_information(nfc_tag_h tag,
        ret = net_nfc_get_tag_info_keys((net_nfc_target_info_h)tag,
                &keys, &count);
 
-       if(ret != NET_NFC_OK)
+       if (ret != NET_NFC_OK)
                return nfc_common_convert_error_code(__func__, ret);
 
        for (i = 0; i < count; i++) {
@@ -461,9 +453,8 @@ static void _mifare_authenticate_with_keyA_cb(net_nfc_error_e result,
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -501,9 +492,8 @@ int nfc_mifare_authenticate_with_keyA(nfc_tag_h tag,
                                        auth_key_data,
                                        _mifare_authenticate_with_keyA_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -536,9 +526,8 @@ static void _mifare_authenticate_with_keyB_cb(net_nfc_error_e result,
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -578,9 +567,8 @@ int nfc_mifare_authenticate_with_keyB(nfc_tag_h tag,
                                        auth_key_data,
                                        _mifare_authenticate_with_keyB_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -658,9 +646,8 @@ int nfc_mifare_read_block(nfc_tag_h tag,
                                block_index,
                                _mifare_read_block_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -689,15 +676,8 @@ int nfc_mifare_read_page(nfc_tag_h tag,
                GPOINTER_TO_UINT(callback),
                GPOINTER_TO_UINT(user_data));
        if (parameter != NULL) {
-               /* FIXME : not implemented */
-//             ret = net_nfc_client_mifare_read_block(tag,
-//                     page_index,
-//                     _mifare_read_page_cb,
-//                     parameter);
-//             if (ret != NET_NFC_OK) {
-                       g_variant_unref(parameter);
-                       ret = NET_NFC_OK;
-//             }
+               g_variant_unref(parameter);
+               ret = NET_NFC_OK;
        } else {
                ret = NET_NFC_ALLOC_FAIL;
        }
@@ -722,9 +702,8 @@ static void _mifare_write_block_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -767,9 +746,8 @@ int nfc_mifare_write_block(nfc_tag_h tag,
                                        block_data,
                                        _mifare_write_block_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -802,9 +780,8 @@ static void _mifare_write_page_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -846,9 +823,8 @@ int nfc_mifare_write_page(nfc_tag_h tag,
                                        block_data,
                                        _mifare_write_page_cb,
                                        parameter);
-                               if (ret != NET_NFC_OK) {
+                               if (ret != NET_NFC_OK)
                                        g_variant_unref(parameter);
-                               }
                        } else {
                                ret = NET_NFC_ALLOC_FAIL;
                        }
@@ -881,9 +857,8 @@ static void _mifare_increment_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -918,9 +893,8 @@ int nfc_mifare_increment(nfc_tag_h tag,
                                value,
                                _mifare_increment_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -948,9 +922,8 @@ static void _mifare_decrement_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -985,9 +958,8 @@ int nfc_mifare_decrement(nfc_tag_h tag,
                                value,
                                _mifare_decrement_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -1015,9 +987,8 @@ static void _mifare_transfer_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -1050,9 +1021,8 @@ int nfc_mifare_transfer(nfc_tag_h tag,
                                block_index,
                                _mifare_transfer_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }
@@ -1080,9 +1050,8 @@ static void _mifare_restore_cb(net_nfc_error_e result, void *user_data)
                (guint *)&callback,
                (guint *)&user_param);
 
-       if (callback != NULL) {
+       if (callback != NULL)
                callback(nfc_common_convert_error_code(__func__, result), user_param);
-       }
 
        g_variant_unref((GVariant *)user_data);
 }
@@ -1115,9 +1084,8 @@ int nfc_mifare_restore(nfc_tag_h tag,
                                block_index,
                                _mifare_restore_cb,
                                parameter);
-                       if (ret != NET_NFC_OK) {
+                       if (ret != NET_NFC_OK)
                                g_variant_unref(parameter);
-                       }
                } else {
                        ret = NET_NFC_ALLOC_FAIL;
                }

diff --git a/test/nfc_unit_test.c b/test/nfc_unit_test.c
index 8f66922..775bbc7 100644 (file)
--- a/test/nfc_unit_test.c
+++ b/test/nfc_unit_test.c
@@ -18,58 +18,48 @@ typedef struct {
 } tc_table_t;
 
 tc_table_t tc_table[] = {
-       /* manage api*/
-       {"nfc_manager_initialize" ,1}, //OK
+       {"nfc_manager_initialize", 1},
        {"nfc_snep_register_server", 2},
-
-    /* -----------*/
-    {"Finish"               , 0x00ff},
-    {NULL                   , 0x0000},
+       {"Finish"               , 0x00ff},
+       {NULL                   , 0x0000},
 };
 
 void tc_usage_print(void)
 {
        int i = 0;
 
-       while (tc_table[i].tc_name)
-       {
+       while (tc_table[i].tc_name) {
                if (tc_table[i].tc_code != 0x00ff)
-               {
                        TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
-               }
                else
-               {
-         TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
-               }
+                       TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
 
                i++;
        }
 }
 
-
 void _nfc_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)
 {
        TC_PRT("Inside _nfc_snep_event_cb");
-       switch(event)
-       {
-               case NFC_SNEP_EVENT_STOP:
-                       TC_PRT("NFC_SNEP_EVENT_STOP");
-                       break;
-               case NFC_SNEP_EVENT_START:
-                       TC_PRT("NFC_SNEP_EVENT_START");
-                       break;
-               case NFC_SNEP_EVENT_GET:
-                       TC_PRT("NFC_SNEP_EVENT_GET");
-                       break;
-               case NFC_SNEP_EVENT_PUT:
-                       TC_PRT("NFC_SNEP_EVENT_PUT");
-                       break;
-               case NFC_SNEP_EVENT_REGISTER:
-                       TC_PRT("NFC_SNEP_EVENT_REGISTER");
-                       break;
-               case NFC_SNEP_EVENT_UNREGISTER:
-                       TC_PRT("NFC_SNEP_EVENT_UNREGISTER");
-                       break;
+       switch (event) {
+       case NFC_SNEP_EVENT_STOP:
+               TC_PRT("NFC_SNEP_EVENT_STOP");
+               break;
+       case NFC_SNEP_EVENT_START:
+               TC_PRT("NFC_SNEP_EVENT_START");
+               break;
+       case NFC_SNEP_EVENT_GET:
+               TC_PRT("NFC_SNEP_EVENT_GET");
+               break;
+       case NFC_SNEP_EVENT_PUT:
+               TC_PRT("NFC_SNEP_EVENT_PUT");
+               break;
+       case NFC_SNEP_EVENT_REGISTER:
+               TC_PRT("NFC_SNEP_EVENT_REGISTER");
+               break;
+       case NFC_SNEP_EVENT_UNREGISTER:
+               TC_PRT("NFC_SNEP_EVENT_UNREGISTER");
+               break;
        }
 }
 
@@ -94,34 +84,33 @@ int test_input_callback(void *data)
                TC_PRT("Finished");
                g_main_loop_quit(main_loop);
                break;
-       case 1: //nfc_manager_initialize
+       case 1:
                {
                        int ret;
                        ret = nfc_manager_initialize();
 
-                       if(ret == NFC_ERROR_NONE)
+                       if (ret == NFC_ERROR_NONE)
                                TC_PRT("nfc initialize success");
                        else
                                TC_PRT("nfc initialize failed");
                }
                break;
-       case 2: //TBT - snep behavior
+       case 2:
                {
                        int ret;
                        ret = nfc_manager_initialize();
 
-                       if(ret == NFC_ERROR_NONE)
-                       {
+                       if (ret == NFC_ERROR_NONE) {
                                TC_PRT("register cb");
                                nfc_manager_set_p2p_target_discovered_cb(_nfc_p2p_target_discovered_cb, NULL);
                        }
                }
-       case 3: //nfc_snep_register_server
+       case 3:
                {
                        int ret;
                        ret = nfc_snep_register_server("default", 4, NULL, NULL);
 
-                       if(ret == NFC_ERROR_NONE)
+                       if (ret == NFC_ERROR_NONE)
                                TC_PRT("success");
                        else
                                TC_PRT("failed");
@@ -130,12 +119,12 @@ int test_input_callback(void *data)
                break;
        }
 
-    return 0;
+       return 0;
 }
 
 static gboolean key_event_cb(GIOChannel *chan,
-                GIOCondition cond,
-                gpointer data)
+               GIOCondition cond,
+               gpointer data)
 {
        char buf[BUFFER_LEN] = { 0 };
 
@@ -161,10 +150,6 @@ int main(int argc, char ** argv)
 {
        GIOChannel *key_io;
 
-//#if !GLIB_CHECK_VERSION(2,35,0)
-//   g_type_init();
-//#endif
-
        key_io = g_io_channel_unix_new(fileno(stdin));
 
        g_io_channel_set_encoding(key_io, NULL, NULL);