Improve variable naming style

Change-Id: I04a989d5ebd9b50ede2352df195707dd84c8d3b2
Signed-off-by: taemin.yeom <taemin.yeom@samsung.com>

diff --git a/src/battery.c b/src/battery.c
index 56d194a..d87c3a8 100644 (file)
--- a/src/battery.c
+++ b/src/battery.c
@@ -35,16 +35,16 @@
 
 static int is_battery_supported(void)
 {
-       int ret;
+       int ret_val;
        bool battery_avail;
 
-       ret = system_info_get_platform_bool(BATTERY_FEATURE, &battery_avail);
-       if (ret < 0) {
+       ret_val = system_info_get_platform_bool(BATTERY_FEATURE, &battery_avail);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
                _E("Failed to get value of battery feature");
                return false;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !battery_avail) {
+       } else if (ret_val == 0 && !battery_avail) {
 //LCOV_EXCL_START System Error
                _D("Battery is not supported");
                return false;
@@ -57,18 +57,18 @@ static int is_battery_supported(void)
 int device_battery_get_percent(int *percent)
 {
        struct device_battery_info info;
-       int ret;
+       int ret_val;
 
        if (!percent)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_battery_supported();
-       if (!ret)
+       ret_val = is_battery_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = device_battery_get_info_direct(&info);
-       if (ret < 0)
-               return ret; //LCOV_EXCL_LINE System Error
+       ret_val = device_battery_get_info_direct(&info);
+       if (ret_val < 0)
+               return ret_val; //LCOV_EXCL_LINE System Error
 
        *percent = info.capacity;
        return DEVICE_ERROR_NONE;
@@ -76,20 +76,20 @@ int device_battery_get_percent(int *percent)
 
 int device_battery_is_charging(bool *charging)
 {
-       int ret, val;
+       int ret_val, val;
 
        if (!charging)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_battery_supported();
-       if (!ret)
+       ret_val = is_battery_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &val);
+       ret_val = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &val);
        /* regard not supported as disconnected */
        if (val == -ENOTSUP)
                val = 0; //LCOV_EXCL_LINE System Error
-       else if (ret < 0 || val < 0 || val > 1)
+       else if (ret_val < 0 || val < 0 || val > 1)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        *charging = val;
@@ -98,17 +98,17 @@ int device_battery_is_charging(bool *charging)
 
 int device_battery_get_level_status(device_battery_level_e *status)
 {
-       int val, ret;
+       int val, ret_val;
 
        if (!status)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_battery_supported();
-       if (!ret)
+       ret_val = is_battery_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &val);
-       if (ret < 0)
+       ret_val = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_LEVEL_STATUS, &val);
+       if (ret_val < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        if (val == VCONFKEY_SYSMAN_BAT_LEVEL_EMPTY)
@@ -154,19 +154,19 @@ static void battery_get_info(struct battery_info *info, void *data)
 
 int device_battery_get_info_direct(struct device_battery_info *info)
 {
-       int ret;
+       int ret_val;
 
        if (!info)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_battery_supported();
-       if (!ret)
+       ret_val = is_battery_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = hal_device_battery_get_current_state(battery_get_info, info);
-       if (ret < 0) {
+       ret_val = hal_device_battery_get_current_state(battery_get_info, info);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
-               _E("Failed to get battery info: %d", ret);
+               _E("Failed to get battery info: %d", ret_val);
                return DEVICE_ERROR_OPERATION_FAILED;
 //LCOV_EXCL_STOP
        }

diff --git a/src/callback.c b/src/callback.c
index b3cf676..29af917 100644 (file)
--- a/src/callback.c
+++ b/src/callback.c
@@ -291,7 +291,7 @@ int device_add_callback(device_callback_e type, device_changed_cb cb, void *data
 {
        struct device_cb_info *cb_info;
        GList *elem, *elem_next;
-       int ret, n;
+       int ret_request, n;
 
        if (!is_feature_display_supported() && type == DEVICE_CALLBACK_DISPLAY_STATE)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -305,8 +305,8 @@ int device_add_callback(device_callback_e type, device_changed_cb cb, void *data
        /* check if it is the first request */
        n = SYS_G_LIST_LENGTH(device_cb_list[type]);
        if (n == 0) {
-               ret = register_request(type);
-               if (ret < 0)
+               ret_request = register_request(type);
+               if (ret_request < 0)
                        return DEVICE_ERROR_OPERATION_FAILED;
        }
 
@@ -333,7 +333,7 @@ int device_remove_callback(device_callback_e type, device_changed_cb cb)
 {
        struct device_cb_info *cb_info;
        GList *elem, *elem_next;
-       int ret, n;
+       int ret_request, n;
 
        if (!is_feature_display_supported() && type == DEVICE_CALLBACK_DISPLAY_STATE)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -360,8 +360,8 @@ int device_remove_callback(device_callback_e type, device_changed_cb cb)
        /* check if this callback is last element */
        n = SYS_G_LIST_LENGTH(device_cb_list[type]);
        if (n == 0) {
-               ret = release_request(type);
-               if (ret < 0)
+               ret_request = release_request(type);
+               if (ret_request < 0)
                        return DEVICE_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE System Error
        }
 

diff --git a/src/common.c b/src/common.c
index 8545e10..7a8ea3d 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -63,13 +63,13 @@ int check_async_call_rate(long *num_calls)
        static int status;
        static struct timeval prev;
        struct timeval cur;
-       int ret;
+       int ret_val;
 
        if (status < 0)
                return status;
 
-       ret = gettimeofday(&cur, NULL);
-       if (ret < 0)
+       ret_val = gettimeofday(&cur, NULL);
+       if (ret_val < 0)
                return 0;
 
        if (*num_calls > 0) {
@@ -103,7 +103,7 @@ int check_async_call_rate(long *num_calls)
 //LCOV_EXCL_START Not used function
 bool is_emulator(void)
 {
-       int ret;
+       int ret_val;
        char *model_name = NULL;
        static bool emul = false;
        static int set = 0;
@@ -111,9 +111,9 @@ bool is_emulator(void)
        if (set)
                return emul;
 
-       ret = system_info_get_platform_string(MODEL_NAME, &model_name);
-       if (ret < 0) {
-               _E("Cannot get model name(%d)", ret);
+       ret_val = system_info_get_platform_string(MODEL_NAME, &model_name);
+       if (ret_val < 0) {
+               _E("Cannot get model name(%d)", ret_val);
                return emul;
        }
 

diff --git a/src/display.c b/src/display.c
index d6480a1..25f3fe8 100644 (file)
--- a/src/display.c
+++ b/src/display.c
@@ -66,10 +66,10 @@ static int alloc_display(void)
 
 int device_display_get_numbers(int *device_number)
 {
-       int ret, val;
+       int ret_val, reply;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!device_number)
@@ -77,12 +77,12 @@ int device_display_get_numbers(int *device_number)
 
        /* if it is a first request */
        if (display_cnt < 0) {
-               ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+               ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
-                               METHOD_GET_DISPLAY_COUNT, NULL, &val);
-               if (ret < 0)
-                       return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
-               display_cnt = val;
+                               METHOD_GET_DISPLAY_COUNT, NULL, &reply);
+               if (ret_val < 0)
+                       return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
+               display_cnt = reply;
                alloc_display();
        }
 
@@ -93,19 +93,19 @@ int device_display_get_numbers(int *device_number)
 
 int device_display_get_max_brightness(int display_index, int *max_brightness)
 {
-       int ret, val;
+       int ret_val, reply;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!max_brightness)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (display_index < 0 || display_index >= display_cnt)
@@ -115,13 +115,13 @@ int device_display_get_max_brightness(int display_index, int *max_brightness)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        if (display_arr[display_index].normal_max < 0) {
-               ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+               ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                                METHOD_GET_MAX_BRIGHTNESS, g_variant_new("(i)", (int)DISPLAY_STATE_NORMAL),
-                               &val);
-               if (ret < 0)
-                       return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
-               display_arr[display_index].normal_max = val;
+                               &reply);
+               if (ret_val < 0)
+                       return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
+               display_arr[display_index].normal_max = reply;
        }
 
        *max_brightness = display_arr[display_index].normal_max;
@@ -130,47 +130,47 @@ int device_display_get_max_brightness(int display_index, int *max_brightness)
 
 int device_display_get_brightness(int display_index, int *brightness)
 {
-       int ret, val;
+       int ret_val, reply;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!brightness)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (display_index < 0 || display_index >= display_cnt)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                        METHOD_GET_BRIGHTNESS, g_variant_new("(i)", (int)DISPLAY_STATE_NORMAL),
-                       &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+                       &reply);
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
-       *brightness = val;
+       *brightness = reply;
        return DEVICE_ERROR_NONE;
 }
 
 int device_display_set_brightness(int display_index, int brightness)
 {
-       int ret, max;
+       int ret_val, max;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (display_index < 0 || display_index >= display_cnt)
@@ -182,29 +182,29 @@ int device_display_set_brightness(int display_index, int brightness)
        if (brightness < 0 || brightness > display_arr[display_index].normal_max)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                        METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", (int)DISPLAY_STATE_NORMAL, brightness),
                        NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }
 
 int device_display_get_state(display_state_e *state)
 {
-       int ret, val;
+       int ret_val, val;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!state)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = vconf_get_int(VCONFKEY_PM_STATE, &val);
-       if (ret < 0)
+       ret_val = vconf_get_int(VCONFKEY_PM_STATE, &val);
+       if (ret_val < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        if (val == VCONFKEY_PM_STATE_NORMAL)
@@ -236,7 +236,7 @@ static char *get_state_str(display_state_e state)
 
 static void change_cb(GVariant *result, void *data, GError *err)
 {
-       int ret;
+       int val;
 
        if (!result) {
 //LCOV_EXCL_START System Error
@@ -245,8 +245,8 @@ static void change_cb(GVariant *result, void *data, GError *err)
 //LCOV_EXCL_STOP
        }
 
-       g_variant_get(result, "(i)", &ret);
-       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_CHANGE_STATE, ret);
+       g_variant_get(result, "(i)", &val);
+       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_CHANGE_STATE, val);
 }
 
 int device_display_change_state(display_state_e state)
@@ -301,10 +301,10 @@ int device_display_change_state(display_state_e state)
 //LCOV_EXCL_START Not tested API
 int device_display_get_max_brightness_state(int display_index, display_state_e state, int *brightness)
 {
-       int ret, val;
+       int ret_val, reply;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!brightness)
@@ -314,9 +314,9 @@ int device_display_get_max_brightness_state(int display_index, display_state_e s
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (display_index < 0 || display_index >= display_cnt)
@@ -325,18 +325,18 @@ int device_display_get_max_brightness_state(int display_index, display_state_e s
        if (!display_arr && alloc_display() < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                                METHOD_GET_MAX_BRIGHTNESS, g_variant_new("(i)", (int)state),
-                               &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+                               &reply);
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        if (state == DISPLAY_STATE_NORMAL) {
-               display_arr[display_index].normal_max = val;
+               display_arr[display_index].normal_max = reply;
                *brightness = display_arr[display_index].normal_max;
        } else {
-               display_arr[display_index].dim_max = val;
+               display_arr[display_index].dim_max = reply;
                *brightness = display_arr[display_index].dim_max;
        }
 
@@ -347,10 +347,10 @@ int device_display_get_max_brightness_state(int display_index, display_state_e s
 //LCOV_EXCL_START Not tested API
 int device_display_get_brightness_state(int display_index, display_state_e state, int *brightness)
 {
-       int ret, val;
+       int ret_val, reply;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (!brightness)
@@ -360,22 +360,22 @@ int device_display_get_brightness_state(int display_index, display_state_e state
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (display_index < 0 || display_index >= display_cnt)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                        METHOD_GET_BRIGHTNESS, g_variant_new("(i)", (int)state),
-                       &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+                       &reply);
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
-       *brightness = val;
+       *brightness = reply;
 
        return DEVICE_ERROR_NONE;
 }
@@ -384,16 +384,16 @@ int device_display_get_brightness_state(int display_index, display_state_e state
 //LCOV_EXCL_START Not tested API
 int device_display_set_brightness_state(int display_index, display_state_e state, int brightness)
 {
-       int ret, max;
+       int ret_val, max;
 
-       ret = is_feature_display_supported();
-       if (!ret)
+       ret_val = is_feature_display_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (display_cnt < 0) {
-               ret = device_display_get_numbers(&display_cnt);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_display_get_numbers(&display_cnt);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        if (state > DISPLAY_STATE_SCREEN_DIM)
@@ -419,12 +419,12 @@ int device_display_set_brightness_state(int display_index, display_state_e state
                break;
        }
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                        METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", (int)state, brightness),
                        NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }
@@ -445,16 +445,16 @@ int device_display_change_state_by_reason(display_state_e type, const char *reas
 
 int is_feature_display_supported(void)
 {
-       int ret;
+       int ret_val;
        bool display_avail;
 
-       ret = system_info_get_platform_bool(DISPLAY_FEATURE, &display_avail);
-       if (ret < 0) {
+       ret_val = system_info_get_platform_bool(DISPLAY_FEATURE, &display_avail);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
                _E("Failed to get value of display feature");
                return false;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !display_avail) {
+       } else if (ret_val == 0 && !display_avail) {
 //LCOV_EXCL_START System Error
                _D("Display feature is not supported");
                return false;
@@ -465,16 +465,16 @@ int is_feature_display_supported(void)
 
 int is_feature_display_state_supported(void)
 {
-       int ret;
+       int ret_val;
        bool display_state_avail;
 
-       ret = system_info_get_platform_bool(DISPLAY_STATE_FEATURE, &display_state_avail);
-       if (ret < 0) {
+       ret_val = system_info_get_platform_bool(DISPLAY_STATE_FEATURE, &display_state_avail);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
                _E("Failed to get value of display state feature");
                return false;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !display_state_avail) {
+       } else if (ret_val == 0 && !display_state_avail) {
 //LCOV_EXCL_START System Error
                _D("Display state feature is not supported");
                return false;

diff --git a/src/haptic.c b/src/haptic.c
index 1934732..dedb8d0 100644 (file)
--- a/src/haptic.c
+++ b/src/haptic.c
@@ -58,16 +58,16 @@ static GList *handle_list;
 
 static int is_haptic_supported(void)
 {
-       int ret;
+       int ret_val;
        bool haptic_avail;
 
-       ret = system_info_get_platform_bool(VIBRATION_FEATURE, &haptic_avail);
-       if (ret < 0) {
+       ret_val = system_info_get_platform_bool(VIBRATION_FEATURE, &haptic_avail);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
                _E("Failed to get value of haptic feature");
                return false;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !haptic_avail) {
+       } else if (ret_val == 0 && !haptic_avail) {
 //LCOV_EXCL_START System Error
                _D("Haptic is not supported");
                return false;
@@ -78,27 +78,27 @@ static int is_haptic_supported(void)
 
 int device_haptic_get_count(int *device_number)
 {
-       int ret, val;
+       int ret_val, val;
 
        if (!device_number)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_haptic_supported();
-       if (!ret)
+       ret_val = is_haptic_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        /* request to deviced to get haptic count */
-       ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                        VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                        METHOD_GET_COUNT, NULL, &val);
        /**
         * there is no haptic method in no vibration model.
         * so -ENOTSUP means that haptic count is zero.
         */
-       if (ret == -ENOTSUP)
-               ret = 0;
-       else if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val == -ENOTSUP)
+               ret_val = 0;
+       else if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        *device_number = val;
        return DEVICE_ERROR_NONE;
@@ -109,13 +109,13 @@ static void restart_callback(void)
 {
        GList *elem, *elem_next;
        struct haptic_handle *temp;
-       int ret, val;
+       int ret_dbus, val;
 
        SYS_G_LIST_FOREACH_SAFE(handle_list, elem, elem_next, temp) {
-               ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+               ret_dbus = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                                VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                                METHOD_OPEN_DEVICE, g_variant_new("(i)", temp->index), &val);
-               if (ret < 0) {
+               if (ret_dbus < 0) {
                        _E("Failed to open device");
                        continue;
                }
@@ -157,12 +157,12 @@ int device_haptic_open(int device_index, haptic_device_h *device_handle)
        GList *elem, *elem_next;
        struct haptic_handle *handle;
        struct haptic_handle *temp;
-       int ret, max, val;
+       int ret_val, max, val;
        bool found = false;
 
-       ret = device_haptic_get_count(&max);
-       if (ret < 0)
-               return ret;
+       ret_val = device_haptic_get_count(&max);
+       if (ret_val < 0)
+               return ret_val;
 
        if (device_index < 0 || device_index >= max)
                return DEVICE_ERROR_INVALID_PARAMETER;
@@ -170,16 +170,16 @@ int device_haptic_open(int device_index, haptic_device_h *device_handle)
        if (!device_handle)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_haptic_supported();
-       if (!ret)
+       ret_val = is_haptic_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        /* request to deviced to open haptic device */
-       ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                        VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                        METHOD_OPEN_DEVICE, g_variant_new("(i)", device_index), &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        SYS_G_LIST_FOREACH_SAFE(handle_list, elem, elem_next, temp) {
                if (temp->handle == val) {
@@ -223,14 +223,14 @@ int device_haptic_close(haptic_device_h device_handle)
        GList *elem, *elem_next;
        struct haptic_handle *handle = (struct haptic_handle *)device_handle;
        struct haptic_handle *temp;
-       int ret;
+       int ret_val;
        bool found = false;
 
        if (!device_handle)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_haptic_supported();
-       if (!ret)
+       ret_val = is_haptic_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        SYS_G_LIST_FOREACH_SAFE(handle_list, elem, elem_next, temp) {
@@ -245,15 +245,15 @@ int device_haptic_close(haptic_device_h device_handle)
        SYS_G_LIST_REMOVE(handle_list, handle);
 
        /* request to deviced to open haptic device */
-       ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                        VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                        METHOD_CLOSE_DEVICE, g_variant_new("(u)", (unsigned int)handle->handle),
                        NULL);
 
        free(handle);
 
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        if (SYS_G_LIST_LENGTH(handle_list) == 0)
                unsubscribe_dbus_signal(NULL, haptic_id);
@@ -266,7 +266,7 @@ int device_haptic_vibrate(haptic_device_h device_handle, int duration, int feedb
        GList *elem, *elem_next;
        struct haptic_handle *handle = (struct haptic_handle *)device_handle;
        struct haptic_handle *temp;
-       int ret, priority, val;
+       int ret_val, priority, val;
        bool found = false;
 
        if (!device_handle)
@@ -278,8 +278,8 @@ int device_haptic_vibrate(haptic_device_h device_handle, int duration, int feedb
        if (feedback < HAPTIC_FEEDBACK_MIN || feedback > HAPTIC_FEEDBACK_MAX)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_haptic_supported();
-       if (!ret)
+       ret_val = is_haptic_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        priority = HAPTIC_PRIORITY_MIN;
@@ -294,13 +294,13 @@ int device_haptic_vibrate(haptic_device_h device_handle, int duration, int feedb
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        /* request to deviced to vibrate haptic device */
-       ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                        VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                        METHOD_VIBRATE_MONOTONE,
                        g_variant_new("(uiii)", (unsigned int)handle->handle, duration, feedback, priority),
                        &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        if (effect_handle)
                *effect_handle = (haptic_effect_h)val;
@@ -313,14 +313,14 @@ int device_haptic_stop(haptic_device_h device_handle, haptic_effect_h effect_han
        GList *elem, *elem_next;
        struct haptic_handle *handle = (struct haptic_handle *)device_handle;
        struct haptic_handle *temp;
-       int ret;
+       int ret_val;
        bool found = false;
 
        if (!device_handle)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_haptic_supported();
-       if (!ret)
+       ret_val = is_haptic_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        SYS_G_LIST_FOREACH_SAFE(handle_list, elem, elem_next, temp) {
@@ -335,12 +335,12 @@ int device_haptic_stop(haptic_device_h device_handle, haptic_effect_h effect_han
        /* TODO : support to stop haptic effect */
 
        /* request to deviced to open haptic device */
-       ret = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(VIBRATOR_BUS_NAME,
                        VIBRATOR_PATH_HAPTIC, VIBRATOR_INTERFACE_HAPTIC,
                        METHOD_STOP_DEVICE, g_variant_new("(u)", (unsigned int)handle->handle),
                        NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }

diff --git a/src/ir.c b/src/ir.c
index 9213ea7..63a686d 100644 (file)
--- a/src/ir.c
+++ b/src/ir.c
@@ -28,32 +28,32 @@
 
 int device_ir_is_available(bool *available)
 {
-       int ret;
+       int ret_val;
        bool ir_avail;
 
        if (!available)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = system_info_get_platform_bool(IR_FEATURE, &ir_avail);
+       ret_val = system_info_get_platform_bool(IR_FEATURE, &ir_avail);
 
-       if (ret < 0) {
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
                *available = false;
                return DEVICE_ERROR_OPERATION_FAILED;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !ir_avail) {
+       } else if (ret_val == 0 && !ir_avail) {
                *available = false;
                return DEVICE_ERROR_NOT_SUPPORTED;
        }
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_IR,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_IR,
                        DEVICED_INTERFACE_IR, METHOD_IS_AVAILABLE,
                        NULL, NULL);
 
 //LCOV_EXCL_START System Error
-       if (ret == -EACCES || ret == -EPERM)
+       if (ret_val == -EACCES || ret_val == -EPERM)
                return DEVICE_ERROR_PERMISSION_DENIED;
-       if (!ret) {
+       if (!ret_val) {
                *available = false;
                return DEVICE_ERROR_OPERATION_FAILED;
        }
@@ -65,16 +65,16 @@ int device_ir_is_available(bool *available)
 
 int device_ir_transmit(int carrier_frequency, int *pattern, int size)
 {
-       int ret;
+       int ret_val;
        int i;
        bool ir_avail;
        GVariantBuilder *builder;
 
-       ret = device_ir_is_available(&ir_avail);
+       ret_val = device_ir_is_available(&ir_avail);
        if (!ir_avail) {
-               if (ret < 0) {
+               if (ret_val < 0) {
                        _E("IR is not supported or IR operation failed");
-                       return ret;
+                       return ret_val;
                }
 //LCOV_EXCL_START System Error
                _E("IR is not supported");
@@ -95,15 +95,15 @@ int device_ir_transmit(int carrier_frequency, int *pattern, int size)
        for (i = 0; i < size; ++i)
                g_variant_builder_add(builder, "i", pattern[i]);
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_IR,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_IR,
                        DEVICED_INTERFACE_IR, METHOD_TRANSMIT,
                        g_variant_new("(ai)", builder), NULL);
 
        g_variant_builder_unref(builder);
 //LCOV_EXCL_START System Error
-       if (ret == -EACCES || ret == -EPERM)
+       if (ret_val == -EACCES || ret_val == -EPERM)
                return DEVICE_ERROR_PERMISSION_DENIED;
-       if (ret < 0)
+       if (ret_val < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 //LCOV_EXCL_STOP
 

diff --git a/src/led.c b/src/led.c
index d6b0014..8f1c38b 100644 (file)
--- a/src/led.c
+++ b/src/led.c
@@ -42,21 +42,21 @@ static int number_of_devices = -1;
 
 static void __CONSTRUCTOR__ init(void)
 {
-       int ret;
+       int ret_val;
        bool val;
 
-       ret = system_info_get_platform_bool(FRONT_LED_FEATURE, &val);
-       if (ret == SYSTEM_INFO_ERROR_NONE && val)
+       ret_val = system_info_get_platform_bool(FRONT_LED_FEATURE, &val);
+       if (ret_val == SYSTEM_INFO_ERROR_NONE && val)
                support_front_led = true;
 
-       ret = system_info_get_platform_bool(CAMERA_LED_FEATURE, &val);
-       if (ret == SYSTEM_INFO_ERROR_NONE && val)
+       ret_val = system_info_get_platform_bool(CAMERA_LED_FEATURE, &val);
+       if (ret_val == SYSTEM_INFO_ERROR_NONE && val)
                support_camera_led = true;
 }
 
 int device_flash_get_max_brightness(int *max_brightness)
 {
-       int ret, val;
+       int ret_dbus, val;
 
        if (!support_camera_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -64,11 +64,11 @@ int device_flash_get_max_brightness(int *max_brightness)
        if (!max_brightness)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                        METHOD_GET_MAX_BRIGHTNESS, NULL, &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
 
        *max_brightness = val;
        return DEVICE_ERROR_NONE;
@@ -76,7 +76,7 @@ int device_flash_get_max_brightness(int *max_brightness)
 
 int device_flash_get_brightness(int *brightness)
 {
-       int ret, val;
+       int ret_dbus, val;
 
        if (!support_camera_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -84,11 +84,11 @@ int device_flash_get_brightness(int *brightness)
        if (!brightness)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                        METHOD_GET_BRIGHTNESS, NULL, &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
 
        *brightness = val;
        return DEVICE_ERROR_NONE;
@@ -96,31 +96,31 @@ int device_flash_get_brightness(int *brightness)
 
 int device_flash_set_brightness(int brightness)
 {
-       int max, ret;
+       int max, ret_dbus;
 
        if (!support_camera_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = device_flash_get_max_brightness(&max);
-       if (ret < 0)
-               return ret;
+       ret_dbus = device_flash_get_max_brightness(&max);
+       if (ret_dbus < 0)
+               return ret_dbus;
 
        if (brightness < 0 || brightness > max)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        /* if camera API preempt a flash device, it will return -EBUSY error. */
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                        METHOD_SET_BRIGHTNESS, g_variant_new("(ii)", brightness, 0), NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }
 
 int device_led_play_custom(int on, int off, unsigned int color, unsigned int flags)
 {
-       int ret;
+       int ret_dbus;
 
        if (!support_front_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -128,12 +128,12 @@ int device_led_play_custom(int on, int off, unsigned int color, unsigned int fla
        if (on < 0 || off < 0)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                        METHOD_PLAY_CUSTOM, g_variant_new("(iiuu)", on, off, (unsigned int)color, (unsigned int)flags), NULL);
 //LCOV_EXCL_START System Error
-       if (ret < 0)
-               return errno_to_device_error(ret);
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus);
 //LCOV_EXCL_STOP
 
        return DEVICE_ERROR_NONE;
@@ -141,17 +141,17 @@ int device_led_play_custom(int on, int off, unsigned int color, unsigned int fla
 
 int device_led_stop_custom(void)
 {
-       int ret;
+       int ret_dbus;
 
        if (!support_front_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                        METHOD_STOP_CUSTOM, NULL, NULL);
 //LCOV_EXCL_START System Error
-       if (ret < 0)
-               return errno_to_device_error(ret);
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus);
 //LCOV_EXCL_STOP
 
        return DEVICE_ERROR_NONE;
@@ -160,7 +160,7 @@ int device_led_stop_custom(void)
 //LCOV_EXCL_START Not tested API
 int device_multi_led_get_number(int *num_of_leds)
 {
-       int ret, val;
+       int ret_dbus, val;
 
        if (!support_front_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -169,11 +169,11 @@ int device_multi_led_get_number(int *num_of_leds)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (number_of_devices < 0) {
-               ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+               ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_LED, DEVICED_INTERFACE_LED,
                                METHOD_GET_LED_NUMBER, NULL, &val);
-               if (ret < 0)
-                       return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+               if (ret_dbus < 0)
+                       return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
                number_of_devices = val;
        }
 
@@ -188,7 +188,7 @@ int device_multi_led_control(unsigned int color[])
 {
        GVariantBuilder *builder = NULL;
        GVariant *var = NULL;
-       int i, ret;
+       int i, ret_val;
 
        if (!support_front_led)
                return DEVICE_ERROR_NOT_SUPPORTED;
@@ -197,9 +197,9 @@ int device_multi_led_control(unsigned int color[])
                return DEVICE_ERROR_INVALID_PARAMETER;
 
        if (number_of_devices < 0) {
-               ret = device_multi_led_get_number(&number_of_devices);
-               if (ret != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
-                       return ret;
+               ret_val = device_multi_led_get_number(&number_of_devices);
+               if (ret_val != DEVICE_ERROR_NONE) //LCOV_EXCL_LINE System Error
+                       return ret_val;
        }
 
        builder = g_variant_builder_new(G_VARIANT_TYPE("au"));
@@ -209,10 +209,10 @@ int device_multi_led_control(unsigned int color[])
        var = g_variant_new("(au)", builder);
        g_variant_builder_unref(builder);
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_LED,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME, DEVICED_PATH_LED,
                                DEVICED_INTERFACE_LED, METHOD_MULTI_LED_CONTROL, var, NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }

diff --git a/src/memory.c b/src/memory.c
index bd88eaa..9430d9f 100644 (file)
--- a/src/memory.c
+++ b/src/memory.c
@@ -107,13 +107,13 @@ static int _get_meminfo(struct meminfo *mi)
 int device_memory_get_total(unsigned int *total_mem)
 {
        struct meminfo mi;
-       int ret;
+       int ret_val;
 
        if (total_mem == NULL)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = _get_meminfo(&mi);
-       if (ret < 0)
+       ret_val = _get_meminfo(&mi);
+       if (ret_val < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        *total_mem = mi.l[_MI_TOTAL];
@@ -123,13 +123,13 @@ int device_memory_get_total(unsigned int *total_mem)
 int device_memory_get_available(unsigned int *avail_mem)
 {
        struct meminfo mi;
-       int ret;
+       int ret_val;
 
        if (avail_mem == NULL)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = _get_meminfo(&mi);
-       if (ret < 0)
+       ret_val = _get_meminfo(&mi);
+       if (ret_val < 0)
                return DEVICE_ERROR_OPERATION_FAILED;
 
        *avail_mem = mi.l[_MI_FREE] + mi.l[_MI_BUF] + mi.l[_MI_CACHED] + mi.l[_MI_SWAP] - mi.l[_MI_SHMEM];

diff --git a/src/pmqos.c b/src/pmqos.c
index 163a595..f07194a 100644 (file)
--- a/src/pmqos.c
+++ b/src/pmqos.c
@@ -25,18 +25,18 @@
 //LCOV_EXCL_START Not tested API
 int device_pmqos_app_launch_home(int timeout)
 {
-       int ret;
+       int ret_dbus;
 
        if (timeout < 0)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_PMQOS,
                        DEVICED_INTERFACE_PMQOS,
                        METHOD_APP_LAUNCH_HOME,
                        g_variant_new("(i)", timeout), NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }
@@ -45,18 +45,18 @@ int device_pmqos_app_launch_home(int timeout)
 //LCOV_EXCL_START Not tested API
 int device_pmqos_homescreen(int timeout)
 {
-       int ret;
+       int ret_dbus;
 
        if (timeout < 0)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_PMQOS,
                        DEVICED_INTERFACE_PMQOS,
                        METHOD_HOMESCREEN,
                        g_variant_new("(i)", timeout), NULL);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_dbus < 0)
+               return errno_to_device_error(ret_dbus); //LCOV_EXCL_LINE System Error
 
        return DEVICE_ERROR_NONE;
 }

diff --git a/src/power.c b/src/power.c
index cb93172..8256679 100644 (file)
--- a/src/power.c
+++ b/src/power.c
@@ -134,7 +134,7 @@ static void remove_padding_timeout(void)
 //LCOV_EXCL_START Callback function
 static void notice_lock_expired_done(GVariant *result, void *data, GError *err)
 {
-       int val, ret;
+       int val, ret_val;
        GList *l, *l_next;
        char *id, *elem;
        size_t len;
@@ -162,9 +162,9 @@ static void notice_lock_expired_done(GVariant *result, void *data, GError *err)
                _I("Continue Power Lock");
                return;
        } else if (val == 1) { /* Release cpu lock */
-               ret = device_power_release_lock(POWER_LOCK_CPU);
-               if (ret != DEVICE_ERROR_NONE)
-                       _E("Failed to release power(CPU) (%d)", ret);
+               ret_val = device_power_release_lock(POWER_LOCK_CPU);
+               if (ret_val != DEVICE_ERROR_NONE)
+                       _E("Failed to release power(CPU) (%d)", ret_val);
        }
 }
 //LCOV_EXCL_STOP
@@ -181,7 +181,7 @@ static char *get_new_request_id(pid_t pid)
 //LCOV_EXCL_START Callback function
 static int notice_power_lock_expired(void)
 {
-       int ret;
+       int ret_dbus;
        pid_t pid;
        char *req_id;
 
@@ -193,7 +193,7 @@ static int notice_power_lock_expired(void)
                return -ENOMEM;
        }
 
-       ret = dbus_handle_method_async_with_reply_var(
+       ret_dbus = dbus_handle_method_async_with_reply_var(
                        DEVICED_BUS_NAME,
                        DEVICED_PATH_DISPLAY,
                        DEVICED_INTERFACE_DISPLAY,
@@ -202,10 +202,10 @@ static int notice_power_lock_expired(void)
                        notice_lock_expired_done,
                        -1,
                        NULL);
-       if (ret < 0) {
-               _E("Failed to notice power lock expired (%d)", ret);
+       if (ret_dbus < 0) {
+               _E("Failed to notice power lock expired (%d)", ret_dbus);
                free(req_id);
-               return ret;
+               return ret_dbus;
        }
 
        request_id_list = g_list_append(request_id_list, req_id);
@@ -218,15 +218,15 @@ static int notice_power_lock_expired(void)
 //LCOV_EXCL_START Callback function
 static gboolean padding_timeout_expired(gpointer data)
 {
-       int ret, ref;
+       int ret_val, ref;
        int count;
 
        _I("Padding timeout expired");
 
        remove_padding_timeout();
 
-       ret = tracker_get_ref_counter(TRACKER_TYPE_POWER_LOCK, &ref);
-       if (ret != TRACKER_ERROR_NONE) {
+       ret_val = tracker_get_ref_counter(TRACKER_TYPE_POWER_LOCK, &ref);
+       if (ret_val != TRACKER_ERROR_NONE) {
                _E("Failed to get reference count of power lock");
                goto out;
        }
@@ -237,9 +237,9 @@ static gboolean padding_timeout_expired(gpointer data)
                return G_SOURCE_REMOVE;
        }
 
-       ret = tracker_get_tick(TRACKER_TYPE_POWER_LOCK, &count);
-       if (ret != TRACKER_ERROR_NONE) {
-               _E("Failed to get total count of power lock(%d)", ret);
+       ret_val = tracker_get_tick(TRACKER_TYPE_POWER_LOCK, &count);
+       if (ret_val != TRACKER_ERROR_NONE) {
+               _E("Failed to get total count of power lock(%d)", ret_val);
                goto out;
        }
 
@@ -249,9 +249,9 @@ static gboolean padding_timeout_expired(gpointer data)
        }
 
 out:
-       ret = notice_power_lock_expired();
-       if (ret < 0) {
-               _E("Failed to launch power lock expired popup (%d)", ret);
+       ret_val = notice_power_lock_expired();
+       if (ret_val < 0) {
+               _E("Failed to launch power lock expired popup (%d)", ret_val);
                return G_SOURCE_CONTINUE;
        }
 
@@ -282,13 +282,13 @@ static void add_padding_timeout(void)
 //LCOV_EXCL_START Callback function
 static gboolean off_lock_timeout_expired(gpointer data)
 {
-       int ret, ref;
+       int ret_val, ref;
 
        _I("Power lock timeout expired");
 
-       ret = tracker_get_ref_counter(TRACKER_TYPE_POWER_LOCK, &ref);
-       if (ret != TRACKER_ERROR_NONE) {
-               _E("Failed to get reference count of power lock(%d)", ret);
+       ret_val = tracker_get_ref_counter(TRACKER_TYPE_POWER_LOCK, &ref);
+       if (ret_val != TRACKER_ERROR_NONE) {
+               _E("Failed to get reference count of power lock(%d)", ret_val);
                remove_off_lock_timeout();
                return G_SOURCE_REMOVE;
        }
@@ -299,9 +299,9 @@ static gboolean off_lock_timeout_expired(gpointer data)
 
        add_padding_timeout();
 
-       ret = tracker_get_tick(TRACKER_TYPE_POWER_LOCK, &prev_count);
-       if (ret != TRACKER_ERROR_NONE)
-               _E("Failed to get total count of power lock(%d)", ret);
+       ret_val = tracker_get_tick(TRACKER_TYPE_POWER_LOCK, &prev_count);
+       if (ret_val != TRACKER_ERROR_NONE)
+               _E("Failed to get total count of power lock(%d)", ret_val);
 
 out:
        return G_SOURCE_CONTINUE;
@@ -330,7 +330,7 @@ static void add_off_lock_timeout(void)
 
 static void lock_cb(GVariant *result, void *data, GError *err)
 {
-       int ret;
+       int ret_val;
 
        if (!result) {
 //LCOV_EXCL_START System Error
@@ -339,17 +339,17 @@ static void lock_cb(GVariant *result, void *data, GError *err)
 //LCOV_EXCL_STOP
        }
 
-       g_variant_get(result, "(i)", &ret);
-       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_LOCK_STATE, ret);
+       g_variant_get(result, "(i)", &ret_val);
+       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_LOCK_STATE, ret_val);
 
-       if (ret < 0)
+       if (ret_val < 0)
                remove_off_lock_timeout();
 }
 
 static int lock_state(display_state_e state, unsigned int flag, int timeout_ms)
 {
        char *arr[4];
-       int ret;
+       int ret_dbus;
        static int privilege = -1;
 
        if (flag & GOTO_STATE_NOW)
@@ -367,13 +367,13 @@ static int lock_state(display_state_e state, unsigned int flag, int timeout_ms)
        if (privilege < 0) {
                arr[0] = "privilege check";
 
-               ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+               ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                                METHOD_LOCK_STATE, g_variant_new("(sssi)", arr[0], arr[1], arr[2], timeout_ms),
                                NULL);
 //LCOV_EXCL_START System Error
-               if (ret < 0)
-                       return ret;
+               if (ret_dbus < 0)
+                       return ret_dbus;
 //LCOV_EXCL_STOP
                else
                        privilege = 1;
@@ -390,7 +390,7 @@ static int lock_state(display_state_e state, unsigned int flag, int timeout_ms)
 
 static void unlock_cb(GVariant *result, void *data, GError *err)
 {
-       int ret;
+       int ret_val;
 
        if (!result) {
 //LCOV_EXCL_START System Error
@@ -399,14 +399,14 @@ static void unlock_cb(GVariant *result, void *data, GError *err)
 //LCOV_EXCL_STOP
        }
 
-       g_variant_get(result, "(i)", &ret);
-       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_UNLOCK_STATE, ret);
+       g_variant_get(result, "(i)", &ret_val);
+       _D("%s-%s : %d", DEVICED_INTERFACE_DISPLAY, METHOD_UNLOCK_STATE, ret_val);
 }
 
 static int unlock_state(display_state_e state, unsigned int flag)
 {
        char *arr[2];
-       int ret;
+       int ret_dbus;
        static int privilege = -1;
 
        if (flag == PM_SLEEP_MARGIN)
@@ -421,13 +421,13 @@ static int unlock_state(display_state_e state, unsigned int flag)
        if (privilege < 0) {
                arr[0] = "privilege check";
 
-               ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+               ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                                DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY,
                                METHOD_UNLOCK_STATE, g_variant_new("(ss)", arr[0], arr[1]),
                                NULL);
 //LCOV_EXCL_START System Error
-               if (ret < 0)
-                       return ret;
+               if (ret_dbus < 0)
+                       return ret_dbus;
 //LCOV_EXCL_STOP
                else
                        privilege = 1;
@@ -493,7 +493,7 @@ int device_power_request_lock(power_lock_e type, int timeout_ms)
 
 int device_power_release_lock(power_lock_e type)
 {
-       int ret;
+       int ret_val;
 
        _I("power_lock_e = %d", type);
 
@@ -509,32 +509,32 @@ int device_power_release_lock(power_lock_e type)
        }
 
        if (type == POWER_LOCK_CPU && power_locked_CPU) {
-               ret = unlock_state(DISPLAY_STATE_SCREEN_OFF, PM_SLEEP_MARGIN);
-               if (ret == 0) {
+               ret_val = unlock_state(DISPLAY_STATE_SCREEN_OFF, PM_SLEEP_MARGIN);
+               if (ret_val == 0) {
                        remove_off_lock_timeout();
                        remove_padding_timeout();
                        power_locked_CPU = false;
                }
        } else if (type == POWER_LOCK_DISPLAY && power_locked_DISPLAY) {
-               ret = unlock_state(DISPLAY_STATE_NORMAL, PM_KEEP_TIMER);
-               if (ret == 0) power_locked_DISPLAY = false;
+               ret_val = unlock_state(DISPLAY_STATE_NORMAL, PM_KEEP_TIMER);
+               if (ret_val == 0) power_locked_DISPLAY = false;
        }
        else if (type == POWER_LOCK_DISPLAY_DIM && power_locked_DISPLAY_DIM) {
-               ret = unlock_state(DISPLAY_STATE_SCREEN_DIM, PM_KEEP_TIMER);
-               if (ret == 0) power_locked_DISPLAY_DIM = false;
+               ret_val = unlock_state(DISPLAY_STATE_SCREEN_DIM, PM_KEEP_TIMER);
+               if (ret_val == 0) power_locked_DISPLAY_DIM = false;
        }
        else
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       return errno_to_device_error(ret);
+       return errno_to_device_error(ret_val);
 }
 
 int device_power_wakeup(bool dim)
 {
-       int ret;
+       int ret_val;
 
-       ret = is_feature_display_state_supported();
-       if (!ret)
+       ret_val = is_feature_display_state_supported();
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
        if (dim)
@@ -548,7 +548,7 @@ int device_power_reboot(const char *reason)
 {
        const char *method;
        GVariant *param;
-       int ret;
+       int ret_dbus;
 
        if (reason) {
                method = METHOD_POWEROFF_WITH_OPTION;
@@ -558,25 +558,25 @@ int device_power_reboot(const char *reason)
                param = g_variant_new("(s)", TYPE_REBOOT);
        }
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_POWEROFF,
                        DEVICED_INTERFACE_POWEROFF,
                        method, param, NULL);
-       return errno_to_device_error(ret);
+       return errno_to_device_error(ret_dbus);
 }
 //LCOV_EXCL_STOP
 
 //LCOV_EXCL_START Not available to test (Reboot during TCT)
 int device_power_poweroff(void)
 {
-       int ret;
+       int ret_dbus;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_POWEROFF, DEVICED_INTERFACE_POWEROFF,
                        METHOD_POWEROFF, g_variant_new("(s)", TYPE_POWEROFF),
                        NULL);
 
-       return errno_to_device_error(ret);
+       return errno_to_device_error(ret_dbus);
 }
 //LCOV_EXCL_STOP
 
@@ -607,9 +607,9 @@ static int power_load_config(struct parse_result *result, void *data)
 
 static void __CONSTRUCTOR__ power_init(void)
 {
-       int ret;
+       int ret_val;
 
-       ret = config_parse(POWER_CONF, power_load_config, NULL);
-       if (ret < 0)
-               _E("Failed to load config file (%d)", ret); //LCOV_EXCL_LINE Logs
+       ret_val = config_parse(POWER_CONF, power_load_config, NULL);
+       if (ret_val < 0)
+               _E("Failed to load config file (%d)", ret_val); //LCOV_EXCL_LINE Logs
 }

diff --git a/src/temperature.c b/src/temperature.c
index 2712d57..6e6a14b 100644 (file)
--- a/src/temperature.c
+++ b/src/temperature.c
@@ -34,21 +34,21 @@
 
 static int is_temperature_supported(device_thermal_e type)
 {
-       int ret = 0;
+       int ret_val = 0;
        bool thermal_avail;
 
        if (type == DEVICE_THERMAL_AP)
-               ret = system_info_get_platform_bool(THERMAL_AP_FEATURE, &thermal_avail);
+               ret_val = system_info_get_platform_bool(THERMAL_AP_FEATURE, &thermal_avail);
        else if (type == DEVICE_THERMAL_CP)
-               ret = system_info_get_platform_bool(THERMAL_CP_FEATURE, &thermal_avail);
+               ret_val = system_info_get_platform_bool(THERMAL_CP_FEATURE, &thermal_avail);
        else
-               ret = system_info_get_platform_bool(THERMAL_BATTERY_FEATURE, &thermal_avail);
-       if (ret < 0) {
+               ret_val = system_info_get_platform_bool(THERMAL_BATTERY_FEATURE, &thermal_avail);
+       if (ret_val < 0) {
 //LCOV_EXCL_START System Error
-               _E("Failed to get value of temp feature : %d", ret);
+               _E("Failed to get value of temp feature : %d", ret_val);
                return false;
 //LCOV_EXCL_STOP
-       } else if (ret == 0 && !thermal_avail) {
+       } else if (ret_val == 0 && !thermal_avail) {
 //LCOV_EXCL_START System Error
                _D("Temperature is not supported");
                return false;
@@ -59,22 +59,22 @@ static int is_temperature_supported(device_thermal_e type)
 
 int device_thermal_get_temperature(device_thermal_e type, int *temp)
 {
-       int ret, val;
+       int ret_val, val;
 
        if (type > DEVICE_THERMAL_BATTERY)
                return DEVICE_ERROR_INVALID_PARAMETER;
 
-       ret = is_temperature_supported(type);
-       if (!ret)
+       ret_val = is_temperature_supported(type);
+       if (!ret_val)
                return DEVICE_ERROR_NOT_SUPPORTED;
 
-       ret = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
+       ret_val = dbus_handle_method_sync_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_TEMPERATURE,
                        DEVICED_INTERFACE_TEMPERATURE,
                        METHOD_GET_TEMPERATURE, g_variant_new("(i)", type),
                        &val);
-       if (ret < 0)
-               return errno_to_device_error(ret); //LCOV_EXCL_LINE System Error
+       if (ret_val < 0)
+               return errno_to_device_error(ret_val); //LCOV_EXCL_LINE System Error
 
        *temp = val;
        return DEVICE_ERROR_NONE;

diff --git a/src/touchscreen-internal.c b/src/touchscreen-internal.c
index 9b93082..b07430d 100644 (file)
--- a/src/touchscreen-internal.c
+++ b/src/touchscreen-internal.c
@@ -25,25 +25,25 @@
 //LCOV_EXCL_START Not tested API
 int device_touchscreen_enable(dbus_pending_cb cb)
 {
-       int ret;
+       int ret_dbus;
 
-       ret = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_TOUCH, DEVICED_INTERFACE_TOUCH,
                        METHOD_TOUCHSCREEN_ENABLE, NULL, cb, -1, NULL);
 
-       return errno_to_device_error(ret);
+       return errno_to_device_error(ret_dbus);
 }
 //LCOV_EXCL_STOP
 
 //LCOV_EXCL_START Not tested API
 int device_touchscreen_disable(dbus_pending_cb cb)
 {
-       int ret;
+       int ret_dbus;
 
-       ret = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
+       ret_dbus = dbus_handle_method_async_with_reply_var(DEVICED_BUS_NAME,
                        DEVICED_PATH_TOUCH, DEVICED_INTERFACE_TOUCH,
                        METHOD_TOUCHSCREEN_DISABLE, NULL, cb, -1, NULL);
 
-       return errno_to_device_error(ret);
+       return errno_to_device_error(ret_dbus);
 }
 //LCOV_EXCL_STOP