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