setting-display/src/setting-display-brightness.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <setting-display-brightness.h>
  23 #include <dbus/dbus.h>
  24 #include <dbus/dbus-glib-lowlevel.h>
  25
  26
  27 #define SUPPORT_DISABLE_IN_AUTO_MODE 0
  28 #define DISABLE_LOW_BATERY_CHANGE 0 /*disable user to set the brightness when the Mobile is low battery. */
  29
  30 #define Left_Bright_Icon IMG_BRIGTHNESS_LEFT
  31 #define Right_Bright_Icon IMG_BRIGHTNESS_RIGHT
  32 #define SUPPORT_DISPLAY_HOMESCREEN_IMAGE 0
  33
  34 #define AUTO_DISPLAY_ADJUSTMENT_STR _("Auto Display Adjustment")
  35 #define BRIGHTNESS_MAX 100
  36 #define BRIGHTNESS_MIN 1
  37 #define BRIGHTNESS_AUTO_MAX_LEVEL 5
  38 #define BRIGHTNESS_AUTO_MIN_LEVEL -5
  39
  40
  41
  42 static int setting_display_brightness_create(void *cb);
  43 static int setting_display_brightness_destroy(void *cb);
  44 static int setting_display_brightness_update(void *cb);
  45 static int setting_display_brightness_cleanup(void *cb);
  46
  47 static void setting_display_brightness_click_softkey_cancel_cb(void *data, Evas_Object *obj, void *event_info);
  48 static void setting_display_birghtness_bright_slider_value_change_cb(void *data, Evas_Object *obj, void *event_info);
  49 void setting_display_update_slider_icon(Setting_GenGroupItem_Data *item_data, int value);
  50
  51
  52 static void setting_display_set_slider_value(void *data, Evas_Object *obj, double value);
  53
  54 setting_view setting_view_display_brightness = {
  55         .create = setting_display_brightness_create,
  56         .destroy = setting_display_brightness_destroy,
  57         .update = setting_display_brightness_update,
  58         .cleanup = setting_display_brightness_cleanup,
  59 };
  60
  61 /* ***************************************************
  62  *
  63  *basic func
  64  *
  65  ***************************************************/
  66 #define LOW_BATTERY_NOTIFY "Battery is too low, you cannot change brightness"
  67 #define NORMAL_BATTERY_NOTIFY "Battery becomes normal, now you can change brightness.."
  68
  69 #define MAX_CONTENT_LEN 512
  70 #define MAX_LOCAL_BUFSIZE 128
  71 #define DBUS_PATH "/Org/Tizen/System/DeviceD/Process"
  72 #define DBUS_SIGNAL_INTERFACE "org.tizen.system.deviced.Process"
  73 #define DBUS_SIGNAL_NAME "ChangedSiop"
  74
  75 const char *iconPath[SETTING_DISPLAY_ICON_PATH] = {
  76         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_00.png",
  77         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_01.png",
  78         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_02.png",
  79         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_03.png",
  80         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_04.png",
  81         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_05.png",
  82         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_06.png",
  83         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_07.png",
  84         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_08.png",
  85         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_09.png",
  86         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_10.png",
  87         SETTING_ICON_PATH_CFG"brightness_icon/quick_icon_brightness_11.png"
  88 };
  89
  90
  91 static void update_overheating_text(void *data)
  92 {
  93         SettingDisplayUG *ad = (SettingDisplayUG *)data;
  94         int auto_brightnes = 0;
  95         vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_brightnes);
  96         if (ad->data_overheating && ad->data_br_sli) {
  97                 if (ad->data_br_sli->slider_max < 100 && !auto_brightnes) {
  98                         G_FREE(ad->data_overheating->keyStr);
  99                         ad->data_overheating->keyStr = (char *)g_strdup(KeyStr_Brightness_Overheating);
 100                 } else {
 101                         G_FREE(ad->data_overheating->keyStr);
 102                         ad->data_overheating->keyStr = NULL;
 103                 }
 104                 elm_object_item_data_set(ad->data_overheating->item, ad->data_overheating);
 105                 elm_genlist_item_update(ad->data_overheating->item);
 106         }
 107 }
 108 /*------------------------------------------------------ */
 109 /* for client - bus */
 110 /*------------------------------------------------------ */
 111 static DBusHandlerResult setting_brightness_dbus_signal_filter(DBusConnection *conn, DBusMessage *message, void *user_data)
 112 {
 113         SETTING_TRACE_BEGIN;
 114         DBusError error;
 115         dbus_error_init(&error);
 116
 117         /*setting_main_appdata *ad = user_data; */
 118         setting_retvm_if(!user_data , 0, "!user_data ");
 119         SettingDisplayUG *ad = (SettingDisplayUG *)user_data;
 120
 121         int brightness_level;
 122
 123         if (dbus_message_is_signal(message, DBUS_SIGNAL_INTERFACE, DBUS_SIGNAL_NAME)) {
 124                 if (dbus_message_get_args(message, &error,
 125                                           DBUS_TYPE_INT32, &brightness_level,
 126                                           DBUS_TYPE_INVALID) == FALSE) {
 127                         SETTING_TRACE_ERROR("Fail to get data : %s", error.message);
 128                         dbus_error_free(&error);
 129                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 130                 }
 131                 /* update max brightness level*/
 132                 int value = 0;
 133                 vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &value);
 134                 if (!value && ad->data_br_sli) {
 135                         ad->data_br_sli->slider_max = display_get_max_brightness();
 136                         /*device_display_get_max_brightness(0, (int*)&ad->data_br_sli->slider_max); */
 137                         SETTING_TRACE("brightness_level:%d", brightness_level);
 138                         SETTING_TRACE("Brightness max value:%lf", ad->data_br_sli->slider_max);
 139                         vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &value);
 140                         if (value > ad->data_br_sli->slider_max) {
 141                                 vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, ad->data_br_sli->slider_max);
 142                         }
 143                         update_overheating_text(ad);
 144                 }
 145         }
 146
 147         return DBUS_HANDLER_RESULT_HANDLED;
 148 }
 149 static int setting_brightness_dbus_handler_fini(void *user_data)
 150 {
 151         SETTING_TRACE_BEGIN;
 152         /*do safty checking first. */
 153         setting_retvm_if(!user_data , 0, "!user_data ");
 154         SettingDisplayUG *ad = (SettingDisplayUG *)user_data;
 155         setting_retvm_if(!ad->bus, 0, "!ad->bus");
 156
 157         DBusError error;
 158         memset(&error, 0, sizeof(DBusError));
 159         char rule[MAX_LOCAL_BUFSIZE + 1] = {0, };
 160
 161         dbus_error_init(&error);
 162
 163         /* why?? */
 164         /*ad->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error); */
 165
 166         dbus_connection_remove_filter(ad->bus, setting_brightness_dbus_signal_filter, ad);
 167
 168
 169         snprintf(rule, MAX_LOCAL_BUFSIZE, "path='%s',type='signal',interface='%s'", DBUS_PATH, DBUS_SIGNAL_INTERFACE);
 170         dbus_bus_remove_match(ad->bus, rule, &error);
 171
 172         if (dbus_error_is_set(&error)) {
 173                 SETTING_TRACE("Fail to rule unset: %s", error.message);
 174                 dbus_error_free(&error);
 175                 /*return -1; */
 176         }
 177
 178         dbus_connection_close(ad->bus);
 179         dbus_connection_unref(ad->bus);
 180         ad->bus = NULL;
 181         SETTING_TRACE("app signal finalized");
 182         return 0;
 183 }
 184
 185 static int setting_brightness_dbus_handler_init(void *user_data)
 186 {
 187         SETTING_TRACE_BEGIN;
 188         setting_retvm_if(!user_data , 0, "!user_data ");
 189         SettingDisplayUG *ad = (SettingDisplayUG *)user_data;
 190
 191         SETTING_TRACE("[TEST]slider_max: %lf", ad->data_br_sli->slider_max);
 192
 193         if (ad->bus) {
 194                 SETTING_TRACE("already get a bus, need release first.");
 195                 setting_brightness_dbus_handler_fini(ad);
 196                 /*              return -1; */
 197         }
 198         dbus_threads_init_default();
 199         DBusError error;
 200         memset(&error, 0, sizeof(DBusError));
 201         char rule[MAX_LOCAL_BUFSIZE + 1] = {0,};
 202         dbus_error_init(&error);
 203         ad->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 204         if (!ad->bus) {
 205                 SETTING_TRACE("Fail to connect to the D-BUS daemon: %s", error.message);
 206                 dbus_error_free(&error);
 207                 return -1;
 208         }
 209         dbus_connection_set_exit_on_disconnect(ad->bus, FALSE);
 210         dbus_connection_setup_with_g_main(ad->bus, NULL);
 211         snprintf(rule, MAX_LOCAL_BUFSIZE, "path='%s',type='signal',interface='%s'", DBUS_PATH, DBUS_SIGNAL_INTERFACE);
 212
 213         dbus_bus_add_match(ad->bus, rule, &error);
 214         if (dbus_error_is_set(&error)) {
 215                 SETTING_TRACE("Fail to rule set; %s", error.message);
 216                 dbus_bus_remove_match(ad->bus, rule, &error);
 217                 dbus_error_free(&error);
 218                 dbus_connection_close(ad->bus);
 219                 ad->bus = NULL;
 220                 return -1;
 221         }
 222
 223         if (dbus_connection_add_filter(ad->bus, setting_brightness_dbus_signal_filter, user_data, NULL) == FALSE) {
 224                 dbus_bus_remove_match(ad->bus, rule, &error);
 225                 dbus_error_free(&error);
 226                 dbus_connection_close(ad->bus);
 227                 ad->bus = NULL;
 228                 return -1;
 229         }
 230
 231         SETTING_TRACE("app signal initialized");
 232         return 0;
 233 }
 234
 235 static void _brightness_register_event_cb(void *data)
 236 {
 237         SETTING_TRACE_BEGIN;
 238         int ret = 0;
 239         setting_retm_if(data == NULL, , "Data parameter is NULL");
 240         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 241
 242         SETTING_TRACE("[TEST]slider_max: %lf", ad->data_br_sli->slider_max);
 243
 244         if (ad->is_event_registered == 0) {
 245                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS,
 246                                                __display_int_vconf_cb, ad);
 247                 if (ret != 0) {
 248                         SETTING_TRACE_ERROR("failed to register a cb key:%s err:%d",
 249                                             "VCONFKEY_SETAPPL_LCD_BRIGHTNESS", ret);
 250                 }
 251                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS,
 252                                                __display_int_vconf_cb, ad);
 253                 if (ret != 0) {
 254                         SETTING_TRACE_ERROR("failed to register a cb key:%s err:%d",
 255                                             "VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS", ret);
 256                 }
 257                 ad->is_event_registered = 1;
 258                 SETTING_TRACE_END;
 259         }
 260 }
 261
 262 static void _brightness_deregister_event_cb(void *data)
 263 {
 264         SETTING_TRACE_BEGIN;
 265         int ret = 0;
 266         setting_retm_if(data == NULL, , "Data parameter is NULL");
 267         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 268         if (ad->is_event_registered == 1) {
 269                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, __display_int_vconf_cb);
 270                 if (ret != 0) {
 271                         SETTING_TRACE_ERROR("failed to register a cb key:%s err:%d", "VCONFKEY_SETAPPL_LCD_BRIGHTNESS", ret);
 272                 }
 273                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS, __display_int_vconf_cb);
 274                 if (ret != 0) {
 275                         SETTING_TRACE_ERROR("failed to register a cb key:%s err:%d", "VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS", ret);
 276                 }
 277                 ad->is_event_registered = 0;
 278         }
 279         SETTING_TRACE_END;
 280 }
 281 static void
 282 _brightness_slider_delayed_changed_cb(void *data,
 283                                       Evas_Object *obj,
 284                                       void *event_info)
 285 {
 286         SETTING_TRACE_BEGIN;
 287         int value = 0;
 288         setting_retm_if(data == NULL, , "Data parameter is NULL");
 289         SettingDisplayUG *ad = NULL;
 290         Setting_GenGroupItem_Data *list_item =
 291             (Setting_GenGroupItem_Data *) data;
 292         ad = list_item->userdata;
 293         setting_retm_if(ad == NULL, , "ad parameter is NULL");
 294
 295         value = ad->last_requested_level;
 296
 297         if (value >= list_item->slider_min && value <= list_item->slider_max) {
 298                 SETTING_TRACE("brightness is changed to %d", value);
 299                 setting_display_set_slider_value(ad, obj, value);
 300         }
 301
 302         /*_brightness_register_event_cb(ad); */
 303 }
 304 static void _brightness_overheat_check(void *data)
 305 {
 306         SETTING_TRACE_BEGIN;
 307         int value = 0;
 308         int max_brightness = BRIGHTNESS_MAX;
 309         setting_retm_if(data == NULL, , "Data parameter is NULL");
 310         SettingDisplayUG *ad = data;
 311
 312         value = ad->last_requested_level;
 313         int automatic_on = 0;
 314         vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &automatic_on);
 315         if (automatic_on == 0) {
 316                 max_brightness = display_get_max_brightness();
 317                 /*device_display_get_max_brightness(0, (int*)&max_brightness); */
 318                 if (value > max_brightness && max_brightness != BRIGHTNESS_MAX) {
 319                         SETTING_TRACE("max brightness is limited");
 320
 321                         elm_slider_value_set(ad->data_br_sli->eo_check, (double)max_brightness);
 322                         ad->last_requested_level = max_brightness;
 323                         ad->data_br_sli->slider_max = max_brightness;
 324                         SETTING_TRACE("[TEST]slider_max: %lf", ad->data_br_sli->slider_max);
 325                         setting_display_set_slider_value(ad, ad->data_br_sli->eo_check, (double)max_brightness);
 326                         update_overheating_text(ad);
 327                 }
 328         }
 329 }
 330
 331 void static _brightness_slider_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 332 {
 333         SETTING_TRACE_BEGIN;
 334         setting_retm_if(data == NULL, , "Data parameter is NULL");
 335         SettingDisplayUG *ad = NULL;
 336         Setting_GenGroupItem_Data *list_item =
 337             (Setting_GenGroupItem_Data *) data;
 338         ad = list_item->userdata;
 339         setting_retm_if(ad == NULL, , "ad parameter is NULL");
 340
 341         /*_brightness_deregister_event_cb(ad); */
 342         SETTING_TRACE_END;
 343 }
 344
 345 static void _brightness_slider_mouse_up_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 346 {
 347         SETTING_TRACE_BEGIN;
 348         setting_retm_if(data == NULL, , "Data parameter is NULL");
 349         SettingDisplayUG *ad = NULL;
 350         Setting_GenGroupItem_Data *list_item =
 351             (Setting_GenGroupItem_Data *) data;
 352         ad = list_item->userdata;
 353         setting_retm_if(ad == NULL, , "ad parameter is NULL");
 354
 355         _brightness_overheat_check(ad);
 356         SETTING_TRACE_END;
 357 }
 358
 359
 360 #if DISABLE_LOW_BATERY_CHANGE
 361 static void
 362 __low_battery_on_resp_cb(void *data, Evas_Object *obj, void *event_info)
 363 {
 364         SETTING_TRACE_BEGIN;
 365         setting_retm_if(NULL == data, "NULL == data");
 366         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 367         evas_object_del(ad->popup);
 368         ad->popup = NULL;
 369 }
 370
 371 static Eina_Bool __disable_on_idle(void *data)
 372 {
 373         SETTING_TRACE_BEGIN;
 374         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 375
 376         if (ad->popup) {
 377                 evas_object_del(ad->popup);
 378                 ad->popup = NULL;
 379         }
 380         ad->popup = setting_create_popup(ad, ad->win_get, NULL, LOW_BATTERY_NOTIFY,
 381                                          __low_battery_on_resp_cb, POPUP_INTERVAL, FALSE, FALSE, 0);
 382         if (ad->data_br_sli && ad->data_br_sli->item)
 383                 setting_disable_genlist_item(ad->data_br_sli->item);
 384         if (ad->data_br_auto && ad->data_br_auto->item)
 385                 setting_disable_genlist_item(ad->data_br_auto->item);
 386         return FALSE;
 387 }
 388
 389 /* low battery */
 390 static void setting_display_brightness_lowbat_cb(keynode_t *key, void *data)
 391 {
 392         /*      SETTING_TRACE_BEGIN; */
 393         ret_if(data == NULL);
 394         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 395         SETTING_TRACE_BEGIN;
 396
 397         char *vconf_key = vconf_keynode_get_name(key);
 398         SETTING_TRACE("the value of [ %s ] just changed", vconf_key);
 399         ad->low_bat = vconf_keynode_get_int(key);
 400         if (ad->low_bat <= VCONFKEY_SYSMAN_BAT_CRITICAL_LOW) {
 401                 SETTING_TRACE("Battery becomes ctitical low !");
 402                 /*popup was showed by system FW */
 403                 /* disabled */
 404                 if (ad->data_br_sli) setting_disable_genlist_item(ad->data_br_sli->item);
 405                 if (ad->data_br_auto) setting_disable_genlist_item(ad->data_br_auto->item);
 406         } else {
 407                 SETTING_TRACE("Battery becomes normal!");
 408                 if (ad->data_br_sli) {
 409                         int automatic_val, err;
 410                         setting_get_int_slp_key(INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, &automatic_val, &err);
 411                         if (ad->data_br_auto) setting_enable_genlist_item(ad->data_br_auto->item);
 412                         if (automatic_val == SETTING_BRIGHTNESS_AUTOMATIC_OFF) { /* not automatic */
 413                                 if (ad->data_br_sli) setting_enable_genlist_item(ad->data_br_sli->item);
 414                         }
 415                 }
 416         }
 417 }
 418 #endif
 419 #if 0
 420 /*
 421 auto brightness level:-5 ~ 5
 422 convet this auto level to auto brightness value 1~ 100
 423 and then store it into vconf for kernel usage
 424 */
 425 static int __display_auto_brightness_convert_level_to_value(int level)
 426 {
 427         int value = 0;
 428         if (0 == level) {
 429                 value = 50;
 430         } else if (level >= -5 && level < 0) {
 431                 value = (int)(10 * (5 + level) + 0.5);
 432         } else if (level > 0 && level <= 5) {
 433                 value = (int)(50 + 10 * level + 0.5);
 434         }
 435         if (value > BRIGHTNESS_MAX) {
 436                 value = BRIGHTNESS_MAX;
 437         }
 438         if (value < BRIGHTNESS_MIN) {
 439                 value = BRIGHTNESS_MIN;
 440         }
 441         return value;
 442 }
 443
 444 /*
 445 auto brightness value:1~ 100
 446 convet this value to auto brightness level -5 ~ 5
 447 and then show it to user
 448 */
 449 static int __display_auto_brightness_convert_value_to_level(int value)
 450 {
 451         int level = 0;
 452         if (value == 50) {
 453                 level = 0;
 454         } else if (value >= 1 && value < 50) {
 455                 level = -(int)((50 - value) * 0.1 + 0.5);
 456         } else if (value > 50 && value <= 100) {
 457                 level = (int)((value - 50) * 0.1 + 0.5);
 458         }
 459         if (level > BRIGHTNESS_AUTO_MAX_LEVEL) {
 460                 level = BRIGHTNESS_AUTO_MAX_LEVEL;
 461         }
 462         if (level < BRIGHTNESS_AUTO_MIN_LEVEL) {
 463                 level = BRIGHTNESS_AUTO_MIN_LEVEL;
 464         }
 465         return level;
 466 }
 467 #endif
 468
 469 char  *setting_brightness_get_slider_icon(int level)
 470 {
 471         int mapped_level = 0;
 472         if (level <= 1) {
 473                 mapped_level = 0;
 474         } else if (level >= 100) {
 475                 mapped_level = 11;
 476         } else if (level > 1 && level <= 9) {
 477                 mapped_level = 1;
 478         } else {
 479                 mapped_level = (level / 10);
 480         }
 481         SETTING_TRACE_DEBUG("mapped_level:%d", mapped_level);
 482         return iconPath[mapped_level];
 483 }
 484
 485 void setting_display_update_slider_icon(Setting_GenGroupItem_Data *item_data, int value)
 486 {
 487         SETTING_TRACE_BEGIN;
 488         Evas_Object *cur_icon = elm_object_content_get(item_data->eo_check);
 489         char *new_file = setting_brightness_get_slider_icon(value);
 490         elm_image_file_set(cur_icon, new_file, NULL);
 491 }
 492
 493 void __display_int_vconf_cb(keynode_t *key, void *data)
 494 {
 495         SETTING_TRACE_BEGIN;
 496         SettingDisplayUG *ad = data;
 497         retm_if(!data, "Invalid argument: data is NULL");
 498
 499         int status = vconf_keynode_get_int(key);
 500         char *vconf_name = vconf_keynode_get_name(key);
 501         SETTING_TRACE("Enter %s(%s=%d)", __FUNCTION__, vconf_name, status);
 502
 503         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_LCD_BRIGHTNESS)) {
 504                 if (ad->data_br_sli) {
 505                         elm_slider_value_set(ad->data_br_sli->eo_check, status);
 506                         setting_display_update_slider_icon(ad->data_br_sli, status);
 507                 }
 508                 char strValue[BUF_SIZE] = {0};
 509                 int value = 0;
 510                 if (status <= 2) {
 511                         value = (int)(2 * 1000);
 512                 } else {
 513                         value = (int)(status * 1000);
 514                 }
 515                 snprintf(strValue, BUF_SIZE, "%d", value);
 516
 517         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT)) {
 518                 setting_update_gl_item_chk_status(ad->data_br_auto, status);
 519                 if (ad->data_br) {
 520                         ad->data_br->sub_desc = (char *)g_strdup(get_brightness_mode_str());
 521                         elm_object_item_data_set(ad->data_br->item, ad->data_br);
 522                         elm_genlist_item_update(ad->data_br->item);
 523                 }
 524                 if (status) { /*off->on */
 525                         SETTING_TRACE("off->on");
 526
 527                         /*need to update adjust text*/
 528                         if (ad->data_adjust) {
 529                                 G_FREE(ad->data_adjust->keyStr);
 530                                 ad->data_adjust->keyStr = (char *)g_strdup(KeyStr_Brightness_Auto_Adjust);
 531                                 elm_object_item_data_set(ad->data_adjust->item, ad->data_adjust);
 532                                 elm_genlist_item_update(ad->data_adjust->item);
 533
 534                         }
 535
 536 #if SUPPORT_CENTER_POINT
 537                         /*need to show central line when automatic is on.*/
 538                         if (ad->data_br_sli && ad->data_br_sli->eo_check) {
 539                                 /*elm_object_signal_emit(ad->data_br_sli->eo_check,"elm,state,rect,visible","elm"); */
 540                                 elm_layout_signal_emit(ad->data_br_sli->eo_check, "slider,center,point,show", "");
 541                         } else {
 542                                 SETTING_TRACE_ERROR("ad->data_br_sli->eo_check is NULL, failed to send visible signal")
 543                         }
 544 #endif
 545
 546 #if SUPPORT_DISABLE_IN_AUTO_MODE
 547                         if (ad->data_br_sli)
 548                                 setting_disable_genlist_item(ad->data_br_sli->item);
 549 #else
 550                         /*save current slider value at VCONFKEY_SETAPPL_LCD_BRIGHTNESS */
 551                         /* And, slider value should be changed to VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS,to use */
 552                         int val = 50;
 553                         vconf_get_int(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS, &val);
 554                         if (ad->data_br_sli) {
 555                                 ad->data_br_sli->slider_min = BRIGHTNESS_MIN;
 556                                 ad->data_br_sli->slider_max = BRIGHTNESS_MAX;
 557                                 ad->data_br_sli->chk_status = val;
 558                                 elm_object_item_data_set(ad->data_br_sli->item, ad->data_br_sli);
 559                                 elm_genlist_item_update(ad->data_br_sli->item);
 560                         }
 561 #endif
 562
 563                 } else { /*on->off */
 564                         SETTING_TRACE("on->off");
 565
 566                         /*need to update adjust text*/
 567                         if (ad->data_adjust) {
 568                                 G_FREE(ad->data_adjust->keyStr);
 569                                 ad->data_adjust->keyStr = (char *)g_strdup(KeyStr_Brightness_Adjust);
 570                                 elm_object_item_data_set(ad->data_adjust->item, ad->data_adjust);
 571                                 elm_genlist_item_update(ad->data_adjust->item);
 572                         }
 573
 574 #if SUPPORT_CENTER_POINT
 575                         /*need to hide central line when automatic is off*/
 576                         if (ad->data_br_sli && ad->data_br_sli->eo_check) {
 577                                 /*elm_object_signal_emit(ad->data_br_sli->eo_check,"elm,state,rect,hidden","elm"); */
 578                                 elm_layout_signal_emit(ad->data_br_sli->eo_check, "slider,center,point,hide", "");
 579                         } else {
 580                                 SETTING_TRACE_ERROR("ad->data_br_sli->eo_check is NULL, failed to send hidden signal")
 581                         }
 582 #endif
 583
 584 #if SUPPORT_DISABLE_IN_AUTO_MODE
 585                         if (ad->data_br_sli)
 586                                 setting_enable_genlist_item(ad->data_br_sli->item);
 587 #else
 588                         /*save current slider value at VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS,to backup */
 589                         /*And, slider value should be changed to VCONFKEY_SETAPPL_LCD_BRIGHTNESS,to use */
 590                         int val = 50;
 591                         int err;
 592                         setting_get_int_slp_key(INT_SLP_SETTING_LCD_BRIGHTNESS, &val, &err);
 593                         if (ad->data_br_sli) {
 594                                 ad->data_br_sli->slider_min = BRIGHTNESS_MIN;
 595                                 ad->data_br_sli->slider_max = display_get_max_brightness();
 596                                 /*device_display_get_max_brightness(0, (int*)&ad->data_br_sli->slider_max); */
 597                                 ad->data_br_sli->chk_status = val;
 598                                 elm_object_item_data_set(ad->data_br_sli->item, ad->data_br_sli);
 599                                 elm_genlist_item_update(ad->data_br_sli->item);
 600                         }
 601
 602                         /*set the device side value */
 603                         /*err =  device_display_set_brightness(0, val); */
 604                         err = display_set_brightness_with_setting(val);
 605                         if (err != DEVICE_ERROR_NONE) {
 606                                 SETTING_TRACE(" device_display_set_brightness : failed[ret=%d]", err);
 607                                 setting_create_popup(ad, ad->win_get, NULL, "IDS_CST_POP_FAILED",
 608                                                                  NULL, POPUP_INTERVAL, FALSE, FALSE, 0);
 609                         }
 610 #endif
 611
 612                 }
 613                 update_overheating_text(ad);
 614         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS)) {
 615                 int auto_matic_status = 0;
 616                 vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &auto_matic_status);
 617                 if (auto_matic_status && ad->data_br_sli) {
 618                         elm_slider_value_set(ad->data_br_sli->eo_check, status);
 619                 }
 620         }
 621         return;
 622 }
 623
 624 const char *__display_brightness_get_vconf_need_save()
 625 {
 626         int state = 0;
 627         vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &state);
 628         if (state) {
 629                 return VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS;
 630         } else {
 631                 return VCONFKEY_SETAPPL_LCD_BRIGHTNESS;
 632         }
 633 }
 634 static double _step_size_calculate(Evas_Object *obj, double min, double max)
 635 {
 636         double step = 0.0;
 637         int steps = 0;
 638
 639         steps = max - min;
 640         if (steps) step = (1.0 / steps);
 641         return step;
 642 }
 643
 644 static char *_setting_display_brightness_indicator_format(double val)
 645 {
 646         char buf[16] = {0,};
 647         int value = (int)(val + 0.5);
 648
 649         value = value / 10;
 650         value = value - 5;
 651         snprintf(buf, 15, "%d", value);
 652
 653         return strdup(buf);
 654 }
 655
 656 static void _indicator_free(char *str)
 657 {
 658         free(str);
 659 }
 660
 661 static Evas_Object *__setting_brightness_add_slider(void *data, Evas_Object *obj, const char *part)
 662 {
 663         SETTING_TRACE_BEGIN;
 664         setting_retvm_if(!data || !obj, NULL, "!data || !obj");
 665         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 666         retv_if(!data, NULL);
 667         Eina_List *items = NULL;
 668         if (!safeStrCmp(part, "elm.icon")) {
 669                 Evas_Object *slider = elm_slider_add(obj);      /*  "elm/slider/horizontal/default" */
 670                 retv_if(slider == NULL, NULL);
 671
 672                 int auto_value = SETTING_BRIGHTNESS_AUTOMATIC_ON;
 673                 int err;
 674                 int ret = setting_get_int_slp_key(INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, &auto_value, &err);/*if get failed,to hold value SETTING_BRIGHTNESS_AUTOMATIC_ON */
 675                 elm_layout_signal_emit(item_data->eo_check, "elm,state,val,hide", "");
 676                 SETTING_TRACE("auto_value:%d", auto_value);
 677                 if (0 != ret) {
 678                         /*add error handle,due to different target env.. */
 679                         SETTING_TRACE_ERROR("Failed to get value of [%s]", VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT);
 680                 }
 681                 if (auto_value) {
 682                         double step;
 683                         elm_slider_indicator_show_set(slider, EINA_TRUE);
 684                         elm_slider_indicator_format_function_set(slider, _setting_display_brightness_indicator_format, _indicator_free);
 685                         elm_object_style_set(slider, "center_point");
 686                         elm_slider_indicator_format_set(slider, "%1.0f");
 687                         step = _step_size_calculate(slider, BRIGHTNESS_AUTO_MIN_LEVEL, BRIGHTNESS_AUTO_MAX_LEVEL);
 688                         elm_slider_step_set(slider, step);
 689                 }
 690                 elm_slider_min_max_set(slider, BRIGHTNESS_MIN, BRIGHTNESS_MAX);
 691                 /*elm_object_style_set(slider,"tap_to_drag"); */
 692                 evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
 693                 evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
 694
 695
 696                 if (item_data->chk_change_cb) {
 697                         evas_object_smart_callback_add(slider, "changed", item_data->chk_change_cb, item_data);
 698                 }
 699                 if (item_data->stop_change_cb) {
 700                         evas_object_smart_callback_add(slider, "slider,drag,stop", item_data->stop_change_cb, item_data);
 701                 }
 702                 if (item_data->start_change_cb) {
 703                         evas_object_smart_callback_add(slider, "slider,drag,start", item_data->start_change_cb, item_data);
 704                 }
 705                 evas_object_event_callback_add(slider, EVAS_CALLBACK_MOUSE_DOWN, _brightness_slider_mouse_down_cb, item_data);
 706                 evas_object_event_callback_add(slider, EVAS_CALLBACK_MOUSE_UP, _brightness_slider_mouse_up_cb, item_data);
 707                 evas_object_smart_callback_add(slider, "delay,changed",
 708                                                _brightness_slider_delayed_changed_cb, item_data);
 709 #if 0
 710                 Evas_Object *icon1 = elm_icon_add(slider);
 711                 elm_image_file_set(icon1, item_data->l_swallow_path, NULL);
 712                 evas_object_size_hint_aspect_set(icon1, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 713
 714                 Evas_Object *icon2 = elm_icon_add(slider);
 715                 elm_image_file_set(icon2, item_data->r_swallow_path, NULL);
 716                 evas_object_size_hint_aspect_set(icon2, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 717
 718                 elm_object_content_set(slider, icon1);
 719                 elm_object_part_content_set(slider, "end", icon2);
 720 #else
 721                 Evas_Object *icon1 = elm_icon_add(slider);
 722                 elm_image_file_set(icon1, item_data->l_swallow_path, NULL);
 723                 evas_object_size_hint_aspect_set(icon1, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 724                 elm_object_content_set(slider, icon1);
 725 #endif
 726                 elm_slider_value_set(slider, item_data->chk_status);
 727                 evas_object_pass_events_set(slider, 1);
 728                 evas_object_propagate_events_set(slider, 0);
 729                 item_data->eo_check = slider;
 730
 731
 732 #if SUPPORT_CENTER_POINT
 733                 if (auto_value) {
 734                         /*elm_object_signal_emit(item_data->eo_check,"elm,state,rect,visible","elm"); */
 735                         elm_layout_signal_emit(item_data->eo_check, "slider,center,point,show", "");
 736                 } else {
 737                         /*elm_object_signal_emit(item_data->eo_check,"elm,state,rect,hidden","elm"); */
 738                         elm_layout_signal_emit(item_data->eo_check, "slider,center,point,hide", "");
 739                 }
 740 #endif
 741                 if (item_data->item) {
 742                         /* convey highlight to its content */
 743                         items = eina_list_append(items, slider);
 744                         elm_object_item_access_order_set(item_data->item, items);
 745                 }
 746                 return slider;
 747         }
 748         return NULL;
 749 }
 750 char *__item_multiline_overheating_text_get(void *data, Evas_Object *obj, const char *part)
 751 {
 752         /*SETTING_TRACE_BEGIN; */
 753         setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
 754         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 755         char *ret_str = NULL;
 756         if (!safeStrCmp(part, "elm.text") || !safeStrCmp(part, "elm.text.1")) {
 757                 if (item_data->keyStr && item_data->sub_desc) {
 758                         if (!safeStrCmp(item_data->sub_desc, "overheating")) {
 759                                 ret_str = setting_customize_text(_(item_data->keyStr), -1, "#FF0000", "middle");
 760                         }
 761                 }
 762         }
 763
 764         return ret_str;
 765 }
 766
 767 void construct_brightness(void *data, Evas_Object *genlist)
 768 {
 769         SETTING_TRACE_BEGIN;
 770         ret_if(data == NULL);
 771         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 772         setting_create_Gendial_itc("slider.main", &(ad->itc_1icon));
 773         char *left_icon = NULL;
 774         ad->itc_1icon.func.content_get = __setting_brightness_add_slider;
 775         ad->last_requested_level = -1;
 776
 777         /* [control] AUTOMATIC - boolean - vconf */
 778         int auto_value = SETTING_BRIGHTNESS_AUTOMATIC_ON;
 779         int err;
 780         int ret = setting_get_int_slp_key(INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, &auto_value, &err);/*if get failed,to hold value SETTING_BRIGHTNESS_AUTOMATIC_ON */
 781         SETTING_TRACE("auto_value:%d", auto_value);
 782         if (0 != ret) {
 783                 /*add error handle,due to different target env.. */
 784                 SETTING_TRACE_ERROR("Failed to get value of [%s]", VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT);
 785         }
 786
 787         /* check manual */
 788         int value = SETTING_BRIGHTNESS_LEVEL5;
 789         /*ret = setting_get_int_slp_key(INT_SLP_SETTING_LCD_BRIGHTNESS, &value, &err); */
 790         ret = vconf_get_int(__display_brightness_get_vconf_need_save(), &value);
 791         SETTING_TRACE("******* value = %d ", value);
 792         if (0 != ret) {
 793                 /*add error handle,due to different target env.. */
 794                 SETTING_TRACE_ERROR("Failed to get value of [%s]", __display_brightness_get_vconf_need_save());
 795         }
 796
 797         left_icon = setting_brightness_get_slider_icon(value);
 798         /* [UI] Slider control for Bightness */
 799         ad->data_br_sli =
 800             setting_create_Gendial_field_def(genlist, &(ad->itc_1icon), NULL,
 801                                              NULL, SWALLOW_Type_LAYOUT_SLIDER,
 802                                              left_icon,
 803                                              NULL, value, "IDS_ST_BODY_BRIGHTNESS_M_POWER_SAVING",
 804                                              NULL,
 805                                              setting_display_birghtness_bright_slider_value_change_cb);
 806
 807         if (ad->data_br_sli) {
 808                 ad->data_br_sli->win_main = ad->win_main_layout;
 809                 ad->data_br_sli->evas = ad->evas;
 810                 if (auto_value) {
 811                         ad->data_br_sli->isIndicatorVisible = 1;
 812                         ad->data_br_sli->slider_min = BRIGHTNESS_MIN;
 813                         ad->data_br_sli->slider_max = BRIGHTNESS_MAX;
 814                 } else {
 815                         ad->data_br_sli->slider_min = BRIGHTNESS_MIN;
 816                         ad->data_br_sli->slider_max = display_get_max_brightness();
 817                         ad->data_br_sli->isIndicatorVisible = 0;
 818                 }
 819                 ad->data_br_sli->userdata = ad;
 820
 821                 __BACK_POINTER_SET(ad->data_br_sli);
 822         } else {
 823                 SETTING_TRACE_ERROR("ad->data_br_sli is NULL");
 824         }
 825
 826         char *temp = NULL;
 827         if (auto_value) {
 828                 temp = (char *)g_strdup(KeyStr_Brightness_Auto_Adjust);
 829         } else {
 830                 temp = (char *)g_strdup(KeyStr_Brightness_Adjust);
 831         }
 832
 833         /*ADD_GL_HELP_NO_SEP(genlist, temp); */
 834
 835         if (ad->data_adjust) {
 836                 ad->data_adjust->userdata = ad;
 837                 __BACK_POINTER_SET(ad->data_adjust);
 838                 /*elm_genlist_item_select_mode_set(ad->data_adjust->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); */
 839         } else {
 840                 SETTING_TRACE_ERROR("ad->data_adjust is NULL");
 841         }
 842         G_FREE(temp);
 843
 844
 845         _brightness_register_event_cb(ad);
 846         setting_brightness_dbus_handler_init(ad);
 847 }
 848
 849 void destruct_brightness(void *data)
 850 {
 851         SETTING_TRACE_BEGIN;
 852         ret_if(data == NULL);
 853         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 854         _brightness_deregister_event_cb(ad);
 855         setting_brightness_dbus_handler_fini(ad);
 856         if (ad->popup) {
 857                 evas_object_del(ad->popup);
 858                 ad->popup = NULL;
 859         }
 860         if (ad->set_idler) {
 861                 ecore_idler_del(ad->set_idler);
 862                 ad->set_idler = NULL;
 863         }
 864 }
 865
 866 static int setting_display_brightness_create(void *cb)
 867 {
 868         SETTING_TRACE_BEGIN;
 869         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 870
 871         SettingDisplayUG *ad = (SettingDisplayUG *) cb;
 872         Evas_Object *genlist = elm_genlist_add(ad->win_main_layout);
 873         retvm_if(genlist == NULL, SETTING_RETURN_FAIL, "Cannot set scroller object as contento of layout");
 874         /*elm_object_style_set(genlist, "dialogue"); */
 875         elm_genlist_realization_mode_set(genlist, EINA_TRUE);
 876         elm_genlist_clear(genlist);     /* first to clear list */
 877
 878         /* add basic layout */
 879         if (&setting_view_display_brightness == ad->view_to_load) {
 880                 ad->ly_main =
 881                     setting_create_layout_navi_bar(ad->win_main_layout,
 882                                                    ad->win_get,
 883                                                    "IDS_ST_BODY_BRIGHTNESS_M_POWER_SAVING",
 884                                                    _("IDS_ST_BUTTON_BACK"),
 885                                                    setting_display_brightness_click_softkey_cancel_cb,
 886                                                    ad,
 887                                                    genlist,
 888                                                    &ad->navi_bar, NULL);
 889         } else {
 890                 setting_push_layout_navi_bar("IDS_ST_BODY_BRIGHTNESS_M_POWER_SAVING",
 891                                              _("IDS_ST_BUTTON_BACK"), NULL, NULL,
 892                                              setting_display_brightness_click_softkey_cancel_cb,
 893                                              NULL,
 894                                              NULL, ad, genlist, ad->navi_bar, NULL);
 895         }
 896         /*ad->genlist = genlist; */
 897         evas_object_smart_callback_add(genlist, "realized", __gl_realized_cb, ad);
 898
 899         construct_brightness(ad, genlist);
 900
 901
 902         /*key notifi for refreshing */
 903         if (&setting_view_display_brightness == ad->view_to_load) {
 904                 vconf_notify_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, __display_int_vconf_cb, ad);
 905         }
 906         setting_view_display_brightness.is_create = 1;
 907         return SETTING_RETURN_SUCCESS;
 908 }
 909
 910 static int setting_display_brightness_destroy(void *cb)
 911 {
 912         SETTING_TRACE_BEGIN;
 913
 914         /* error check */
 915         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 916         retv_if(!(setting_view_display_brightness.is_create), SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 917
 918 #if DISABLE_LOW_BATERY_CHANGE
 919         /* low battery handler - registration */
 920         vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, setting_display_brightness_lowbat_cb);
 921 #endif
 922
 923         destruct_brightness(cb);/*------- */
 924
 925         SettingDisplayUG *ad = (SettingDisplayUG *) cb;
 926         if (&setting_view_display_brightness == ad->view_to_load) {
 927                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, __display_int_vconf_cb);
 928         }
 929
 930         if (&setting_view_display_brightness == ad->view_to_load) {
 931                 if (ad->ly_main != NULL) {
 932                         evas_object_del(ad->ly_main);
 933                         ad->ly_main = NULL;
 934                 }
 935                 setting_view_display_brightness.is_create = 0;
 936         } else {
 937                 setting_view_display_brightness.is_create = 0;
 938                 elm_naviframe_item_pop(ad->navi_bar);
 939         }
 940
 941         return SETTING_RETURN_SUCCESS;
 942 }
 943
 944 static int setting_display_brightness_update(void *cb)
 945 {
 946         SETTING_TRACE_BEGIN;
 947         return SETTING_RETURN_SUCCESS;
 948
 949 }
 950
 951 static int setting_display_brightness_cleanup(void *cb)
 952 {
 953         SETTING_TRACE_BEGIN;
 954         /* error check */
 955         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 956         setting_display_brightness_destroy(cb);
 957
 958         return SETTING_RETURN_SUCCESS;
 959 }
 960
 961 /* ***************************************************
 962  *
 963  *general func
 964  *
 965  ***************************************************/
 966
 967 /* ***************************************************
 968  *
 969  *call back func
 970  *
 971  ***************************************************/
 972
 973 static void
 974 setting_display_brightness_click_softkey_cancel_cb(void *data,
 975                                                    Evas_Object *obj,
 976                                                    void *event_info)
 977 {
 978         SETTING_TRACE_BEGIN;
 979         /* error check */
 980         retm_if(data == NULL, "Data parameter is NULL");
 981         SettingDisplayUG *ad = (SettingDisplayUG *) data;
 982         if (&setting_view_display_brightness == ad->view_to_load) {
 983                 /* Send destroy request */
 984                 ug_destroy_me(ad->ug);
 985                 return;
 986         }
 987
 988         setting_view_change(&setting_view_display_brightness,
 989                             &setting_view_display_main, ad);
 990 }
 991
 992
 993 /**
 994  * [UI] 'Automatic' toggle
 995  */
 996 static void setting_display_set_slider_value(void *data, Evas_Object *obj, double value)
 997 {
 998         SETTING_TRACE_BEGIN;
 999         retm_if(data == NULL, "Invalid argument: data is NULL");
1000
1001         SettingDisplayUG *ad = data;
1002         const char *vconf_str = __display_brightness_get_vconf_need_save();
1003         if (!safeStrCmp(vconf_str, VCONFKEY_SETAPPL_LCD_BRIGHTNESS)) {
1004                 int ret, err;
1005                 /*ret =  device_display_set_brightness(0, value);/*this API will set vconf value, so no need to set vconf in setting side* / */
1006                 ret = display_set_brightness_with_setting(value);
1007                 if (ret == DEVICE_ERROR_NONE) {
1008                         ad->data_br_sli->chk_status = (int)value;
1009                         SETTING_TRACE("value:%f", value);
1010                 } else {
1011                         SETTING_TRACE(" device_display_set_brightness : failed[ret=%d]", ret);
1012                         /*rollback.. */
1013                         int tmp = SETTING_BRIGHTNESS_LEVEL5;
1014                         setting_get_int_slp_key(INT_SLP_SETTING_LCD_BRIGHTNESS, &tmp, &err);
1015                         vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &tmp);
1016                         elm_slider_value_set(obj, tmp);
1017                         setting_create_popup(ad, ad->win_get, NULL, "IDS_CST_POP_FAILED",
1018                                                          NULL, POPUP_INTERVAL, FALSE, FALSE, 0);
1019                 }
1020         } else {
1021                 int ret = vconf_set_int(VCONFKEY_SETAPPL_LCD_AUTOMATIC_BRIGHTNESS, value);
1022                 /*add error handle.. */
1023                 if (0 != ret) {
1024                         setting_create_popup(ad, ad->win_get, NULL, "IDS_CST_POP_FAILED",
1025                                                          NULL, POPUP_INTERVAL, FALSE, FALSE, 0);
1026                 }
1027         }
1028 }
1029
1030 static void
1031 setting_display_birghtness_bright_slider_value_change_cb(void *data,
1032                                                          Evas_Object *obj,
1033                                                          void *event_info)
1034 {
1035         SETTING_TRACE_BEGIN;
1036         retm_if(data == NULL, "Data parameter is NULL");
1037         int value = 0;
1038
1039         SettingDisplayUG *ad = NULL;
1040         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
1041         ad = list_item->userdata;
1042         double time_current = 0.0;
1043         static double time_before = 0.0;
1044
1045         time_current = ecore_loop_time_get();
1046
1047         double val = elm_slider_value_get(obj);
1048         SETTING_TRACE("val:%f", val);
1049         value = (int)(val + 0.5);
1050         /* SETTING_TRACE("val:%f", val); */
1051         SETTING_TRACE("value:%d, list_item->slider_max:%lf", value, list_item->slider_max);
1052         if (value != ad->last_requested_level) {
1053                 if (value >= list_item->slider_min && value <= list_item->slider_max) {
1054                         ad->last_requested_level = value;
1055                         SETTING_TRACE("value:%d", value);
1056                         if (time_current - time_before >= 0.1) {
1057                                 setting_display_set_slider_value(ad, obj, value);
1058                                 setting_display_update_slider_icon(ad->data_br_sli, value);
1059                                 time_before = time_current;
1060                         }
1061                 }
1062         }
1063 }
1064
1065