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;
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;
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;
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)
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
}
{
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;
/* 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;
}
{
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;
/* 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
}
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) {
//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;
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;
}
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)
/* 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();
}
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)
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;
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)
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)
static void change_cb(GVariant *result, void *data, GError *err)
{
- int ret;
+ int val;
if (!result) {
//LCOV_EXCL_START System Error
//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)
//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)
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)
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;
}
//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)
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;
}
//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)
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;
}
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;
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;
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;
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;
{
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;
}
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;
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) {
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) {
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);
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)
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;
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;
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) {
/* 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;
}
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;
}
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");
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
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;
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;
int device_flash_get_brightness(int *brightness)
{
- int ret, val;
+ int ret_dbus, val;
if (!support_camera_led)
return DEVICE_ERROR_NOT_SUPPORTED;
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;
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;
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;
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;
//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;
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;
}
{
GVariantBuilder *builder = NULL;
GVariant *var = NULL;
- int i, ret;
+ int i, ret_val;
if (!support_front_led)
return DEVICE_ERROR_NOT_SUPPORTED;
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"));
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;
}
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];
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];
//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;
}
//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;
}
//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;
_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
//LCOV_EXCL_START Callback function
static int notice_power_lock_expired(void)
{
- int ret;
+ int ret_dbus;
pid_t pid;
char *req_id;
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,
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);
//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;
}
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;
}
}
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;
}
//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;
}
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;
static void lock_cb(GVariant *result, void *data, GError *err)
{
- int ret;
+ int ret_val;
if (!result) {
//LCOV_EXCL_START System Error
//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)
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;
static void unlock_cb(GVariant *result, void *data, GError *err)
{
- int ret;
+ int ret_val;
if (!result) {
//LCOV_EXCL_START System Error
//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)
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;
int device_power_release_lock(power_lock_e type)
{
- int ret;
+ int ret_val;
_I("power_lock_e = %d", 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)
{
const char *method;
GVariant *param;
- int ret;
+ int ret_dbus;
if (reason) {
method = METHOD_POWEROFF_WITH_OPTION;
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
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
}
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;
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;
//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