setting-display/src/setting-display.c

   1 /*
   2  * setting
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://floralicense.org/license/
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /**
  19  *@defgroup setting-display
  20  *UG creation code for setting-display
  21  *
  22  *  - Screen Mode
  23  *  - Backlight time
  24  *  - Smart Screen
  25  *  - Battery percentage
  26  */
  27
  28 #include <setting-display.h>
  29 #include <Ecore_X.h>
  30
  31 #define SETTING_BRIGHTNESS_DEFAULT_LEVEL 60
  32
  33 #ifndef UG_MODULE_API
  34 #define UG_MODULE_API __attribute__ ((visibility("default")))
  35 #endif
  36
  37 setting_view *__get_display_view_to_load(service_h service)
  38 {
  39         SETTING_TRACE_BEGIN;
  40
  41         char *viewtype = NULL;
  42
  43         service_get_extra_data(service, "viewtype", &viewtype);
  44         if(!viewtype)
  45                 return NULL;
  46
  47         SETTING_TRACE("viewtype:%s", viewtype);
  48
  49         if (!safeStrCmp(viewtype, "brightness")) {
  50                 setting_view_node_table_register(&setting_view_display_brightness,
  51                                                  NULL);
  52                 return &setting_view_display_brightness;
  53         } else if (!safeStrCmp(viewtype, "wallpaper")) {
  54                 setting_view_node_table_register(&setting_view_display_wallpaper, NULL);
  55                 return &setting_view_display_wallpaper;
  56         } else {
  57                 setting_view_node_table_register(&setting_view_display_main, NULL);
  58                 setting_view_node_table_register(&setting_view_display_screen_mode,
  59                                                  &setting_view_display_main);
  60                 setting_view_node_table_register(&setting_view_display_brightness,
  61                                                  &setting_view_display_main);
  62                 return &setting_view_display_main;
  63         }
  64
  65 }
  66
  67 Evas_Object *__get_display_layout_to_return(service_h service, void *priv)
  68 {
  69         SETTING_TRACE_BEGIN;
  70         SettingDisplayUG *displayUG = priv;
  71         char *viewtype = NULL;
  72
  73         service_get_extra_data(service, "viewtype", &viewtype);
  74         if(!viewtype)
  75                 return NULL;
  76
  77         SETTING_TRACE("viewtype:%s", viewtype);
  78
  79         if (!safeStrCmp(viewtype, "wallpaper")) {
  80                 return displayUG->ly_wall;
  81         } else {
  82                 return displayUG->ly_main;
  83         }
  84
  85 }
  86
  87 static void setting_display_ug_cb_resize(void *data, Evas *e,
  88                                          Evas_Object *obj, void *event_info)
  89 {
  90         SettingDisplayUG *ad = (SettingDisplayUG *) data;
  91         setting_view_update(ad->view_to_load, ad);
  92 }
  93
  94 static void *setting_display_ug_on_create(ui_gadget_h ug,
  95                                           enum ug_mode mode, service_h service,
  96                                           void *priv)
  97 {
  98         setting_retvm_if((!priv), NULL, "!priv");
  99
 100         SettingDisplayUG *displayUG = priv;
 101         displayUG->ug = ug;
 102         setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 103
 104         displayUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 105         displayUG->win_get = (Evas_Object *) ug_get_window();
 106
 107         evas_object_show(displayUG->win_main_layout);
 108         displayUG->evas = evas_object_evas_get(displayUG->win_main_layout);
 109
 110         setting_retvm_if(displayUG->win_main_layout == NULL, NULL,
 111                          "cannot get main window ");
 112
 113
 114         /* register view node table */
 115         setting_view_node_table_intialize();
 116
 117         setting_create_Gendial_itc("dialogue/2text.3",
 118                                    &(displayUG->itc_2text_2));
 119         setting_create_Gendial_itc("dialogue/1text.1icon",
 120                                    &(displayUG->itc_1text_1icon));
 121         setting_create_Gendial_itc("dialogue/2text.3/expandable",
 122                                    &(displayUG->itc_2text_3_parent));
 123         setting_create_Gendial_itc("dialogue/1text.1icon/expandable2",
 124                                    &(displayUG->itc_1icon_1text_sub));
 125         setting_create_Gendial_itc("dialogue/1text", &(displayUG->itc_1text));
 126
 127         displayUG->itc_seperator.item_style = "dialogue/separator";
 128         displayUG->itc_seperator.func.text_get = NULL;
 129         displayUG->itc_seperator.func.content_get = NULL;
 130         displayUG->itc_seperator.func.state_get = NULL;
 131         displayUG->itc_seperator.func.del = NULL;
 132
 133         /*  creating a view. */
 134         displayUG->view_to_load = __get_display_view_to_load(service);
 135         setting_retvm_if(NULL == displayUG->view_to_load, NULL,
 136                          "NULL == displayUG->view_to_load");
 137         setting_view_node_set_cur_view(displayUG->view_to_load);
 138         setting_view_create(displayUG->view_to_load, (void *)displayUG);
 139         evas_object_event_callback_add(displayUG->win_main_layout,
 140                                        EVAS_CALLBACK_RESIZE,
 141                                        setting_display_ug_cb_resize, displayUG);
 142         return __get_display_layout_to_return(service, displayUG);
 143 }
 144
 145 static void setting_display_ug_on_start(ui_gadget_h ug, service_h service,
 146                                         void *priv)
 147 {
 148 }
 149
 150 static void setting_display_ug_on_pause(ui_gadget_h ug, service_h service,
 151                                         void *priv)
 152 {
 153 }
 154
 155 static void setting_display_ug_on_resume(ui_gadget_h ug, service_h service,
 156                                          void *priv)
 157 {
 158 }
 159
 160 static void setting_display_ug_on_destroy(ui_gadget_h ug, service_h service,
 161                                           void *priv)
 162 {
 163         SETTING_TRACE_BEGIN;
 164         setting_retm_if((!priv), "!priv");
 165         SettingDisplayUG *displayUG = priv;
 166
 167         /* fix flash issue for gallery */
 168         evas_object_event_callback_del(displayUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_display_ug_cb_resize);
 169         displayUG->ug = ug;
 170
 171         /*  called when this shared gadget is terminated. similar with app_exit */
 172         if (&setting_view_display_main == displayUG->view_to_load) {
 173                 setting_view_destroy(&setting_view_display_brightness,
 174                                      displayUG);
 175                 setting_view_destroy(&setting_view_display_screen_mode, displayUG);
 176                 setting_view_destroy(&setting_view_display_main, displayUG);
 177         } else if (&setting_view_display_wallpaper == displayUG->view_to_load) {
 178                 setting_view_destroy(&setting_view_display_wallpaper,
 179                                      displayUG);
 180         } else if (&setting_view_display_brightness == displayUG->view_to_load) {
 181                 setting_view_destroy(&setting_view_display_brightness,
 182                                      displayUG);
 183         }
 184
 185         if (NULL != ug_get_layout(displayUG->ug)) {
 186                 evas_object_hide((Evas_Object *) ug_get_layout(displayUG->ug));
 187                 evas_object_del((Evas_Object *) ug_get_layout(displayUG->ug));
 188         }
 189
 190         SETTING_TRACE_END;
 191 }
 192
 193 static void setting_display_ug_on_message(ui_gadget_h ug, service_h msg,
 194                                           service_h service, void *priv)
 195 {
 196         SETTING_TRACE_BEGIN;
 197 }
 198
 199 static void setting_display_ug_on_event(ui_gadget_h ug,
 200                                         enum ug_event event, service_h service,
 201                                         void *priv)
 202 {
 203         SETTING_TRACE_BEGIN;
 204         switch (event) {
 205         case UG_EVENT_LOW_MEMORY:
 206                 break;
 207         case UG_EVENT_LOW_BATTERY:
 208                 break;
 209         case UG_EVENT_LANG_CHANGE:
 210                 break;
 211         case UG_EVENT_ROTATE_PORTRAIT:
 212                 break;
 213         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 214                 break;
 215         case UG_EVENT_ROTATE_LANDSCAPE:
 216                 break;
 217         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 218                 break;
 219         case UG_EVENT_REGION_CHANGE:
 220                 break;
 221         default:
 222                 break;
 223         }
 224 }
 225
 226 static void setting_display_ug_on_key_event(ui_gadget_h ug,
 227                                             enum ug_key_event event,
 228                                             service_h service, void *priv)
 229 {
 230         SETTING_TRACE_BEGIN;
 231         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 232
 233         switch (event) {
 234         case UG_KEY_EVENT_END:
 235                 {
 236                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 237                            elm_naviframe_bottom_item_get(ad->navi_bar)) {
 238                                 ug_destroy_me(ug);
 239                         } else {
 240                                 if (&setting_view_display_brightness ==
 241                                     setting_view_node_get_cur_view()) {
 242                                 }
 243                                 setting_view_cb_at_endKey(ad);
 244                         }
 245                 }
 246                 break;
 247         default:
 248                 break;
 249         }
 250 }
 251
 252 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 253 {
 254         SETTING_TRACE_BEGIN;
 255         SettingDisplayUG *displayUG = calloc(1, sizeof(SettingDisplayUG));
 256         setting_retvm_if(!displayUG, -1, "Create SettingDisplayUG obj failed");
 257
 258         ops->create = setting_display_ug_on_create;
 259         ops->start = setting_display_ug_on_start;
 260         ops->pause = setting_display_ug_on_pause;
 261         ops->resume = setting_display_ug_on_resume;
 262         ops->destroy = setting_display_ug_on_destroy;
 263         ops->message = setting_display_ug_on_message;
 264         ops->event = setting_display_ug_on_event;
 265         ops->key_event = setting_display_ug_on_key_event;
 266         ops->priv = displayUG;
 267         ops->opt = UG_OPT_INDICATOR_ENABLE;
 268
 269         return 0;
 270 }
 271
 272 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 273 {
 274         SETTING_TRACE_BEGIN;
 275         struct SettingDisplayUG *displayUG;
 276         setting_retm_if(!ops, "ops == NULL");
 277
 278         displayUG = ops->priv;
 279         if (displayUG) {
 280                 FREE(displayUG);
 281         }
 282 }
 283
 284 /* ***************************************************
 285  *
 286  *general func
 287  *
 288  ***************************************************/
 289
 290 void setting_display_layout_ug_cb(ui_gadget_h ug, enum ug_mode mode,
 291                                   void *priv)
 292 {
 293         SettingDisplayUG *ad = (SettingDisplayUG *) priv;
 294         Evas_Object *base;
 295
 296         if (!priv)
 297                 return;
 298         SETTING_TRACE_BEGIN;
 299
 300         base = (Evas_Object *) ug_get_layout(ug);
 301         if (!base)
 302                 return;
 303
 304         switch (mode) {
 305         case UG_MODE_FULLVIEW:
 306                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 307                                                  EVAS_HINT_EXPAND);
 308                 //elm_win_resize_object_add(ad->win_get, base);
 309                 evas_object_show(base);
 310                 break;
 311         default:
 312                 break;
 313         }
 314
 315         SETTING_TRACE_END;
 316 }
 317
 318 /*  NESTED*/
 319 static int setting_reset_display_brightness(void)
 320 {
 321         SETTING_TRACE_BEGIN;
 322         int ret = 0;
 323
 324         ret += vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_OFF);
 325
 326         if(isEmulBin())
 327         {
 328                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 329 #if USE_DEVICE_SET_DISPLAY_BRT
 330                 ret += device_set_brightness_to_settings(BRIGHTNESS_DISPLAY, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 331 #endif
 332         }
 333         else
 334         {
 335                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 336 #if USE_DEVICE_SET_DISPLAY_BRT
 337                 ret += device_set_brightness_to_settings(BRIGHTNESS_DISPLAY, SETTING_BRIGHTNESS_DEFAULT_LEVEL);
 338 #endif
 339         }
 340         SETTING_TRACE_END;
 341         return ret;
 342 }
 343
 344 /*  NESTED*/
 345 static int setting_reset_display_backlight(void)
 346 {
 347         SETTING_TRACE_BEGIN;
 348         int ret = 0;
 349 #if SUPPORT_LCD_TIMEOUT_KEEPING
 350         ret += vconf_set_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, 0);
 351 #else
 352         if(isEmulBin())
 353                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 600);
 354         else
 355                 ret += vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 30);
 356 #endif
 357         SETTING_TRACE_END;
 358         return ret;
 359 }
 360
 361 /*  NESTED*/
 362 static int setting_reset_home_wallpaper(void)
 363 {
 364         SETTING_TRACE_BEGIN;
 365         int ret = 0;
 366         ret += vconf_set_str(VCONFKEY_BGSET, IMG_DEFAULT_HOME_SCREEN);
 367         SETTING_TRACE_END;
 368         return ret;
 369 }
 370
 371 /*  NESTED*/
 372 static int setting_reset_display_lc_screen(void)
 373 {
 374         SETTING_TRACE_BEGIN;
 375         int ret = 0;
 376         ret += vconf_set_str(VCONFKEY_IDLE_LOCK_BGSET, IMG_DEFAULT_HOME_SCREEN);
 377         ret += setting_invoke_reset_function("setting-lock", 0, NULL);
 378         return ret;
 379 }
 380
 381 static void setting_reset_launch_effect()
 382 {
 383         SETTING_TRACE_BEGIN;
 384         Evas_Object *win_main = ug_get_window();
 385         Ecore_X_Window xwin = elm_win_xwindow_get(win_main);
 386         Ecore_X_Window root = 0;
 387         if (0 != xwin)
 388         {
 389             root = ecore_x_window_root_get(xwin);
 390         }
 391         if (0 != root)
 392         {
 393                 Ecore_X_Atom effect_enable_atom = ecore_x_atom_get("_NET_CM_EFFECT_ENABLE");
 394                 ret_if(!effect_enable_atom);
 395                 unsigned int is_enable = 0;
 396                 ecore_x_window_prop_card32_set(root, effect_enable_atom, &is_enable, 1);
 397         }
 398
 399 }
 400
 401 /*  NESTED*/
 402 /** @todo setting_display_main_effect_set_value work? */
 403 static int setting_reset_display_main(void)
 404 {
 405         SETTING_TRACE_BEGIN;
 406         int ret = 0;
 407         ret += setting_reset_display_backlight();
 408         //ret += setting_reset_display_brightness();
 409
 410         ret += vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, FALSE);//battery percent
 411         setting_reset_launch_effect();
 412
 413         ret += vconf_set_bool(VCONFKEY_SETAPPL_BOOL_AUTO_ADJUST_SCREEN_TONE, TRUE);
 414
 415         // screen mode
 416         ret += vconf_set_str(VCONFKEY_SETAPPL_SCREENMODE_SELNAME, "Dynamic");
 417         device_set_image_enhance_mode(0);       // 0 => Dynamic
 418         return ret;
 419 }
 420
 421
 422
 423 /*****/
 424 UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
 425 {
 426         SETTING_TRACE_BEGIN;
 427
 428         int ret = 0;
 429         char *ug_type = NULL;
 430
 431         service_get_extra_data(service, "viewtype", &ug_type);
 432         SETTING_TRACE("ug_type:%s", ug_type);
 433         if (0 == safeStrCmp(ug_type, "wallpaper")) {
 434                 /*ret += setting_reset_home_wallpaper();
 435                 ret += setting_reset_display_lc_screen();*/
 436 #if SUPPORT_RUN_SYSTEM_COMMAND
 437                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "wallpaper");
 438                 ret += setting_invoke_reset_function("setting-lock", service, NULL);
 439 #else
 440                 ret += setting_reset_home_wallpaper();
 441                 ret += setting_reset_display_lc_screen();
 442 #endif
 443
 444         } else if (0 == safeStrCmp(ug_type, "main")) {
 445 #if SUPPORT_RUN_SYSTEM_COMMAND
 446                 ret += excuteCmd(SETTING_POSTINST_FILE, 1, "display");
 447                 setting_reset_launch_effect();
 448 #else
 449                 ret +=  setting_reset_display_main();
 450 #endif
 451         } else if (0 == safeStrCmp(ug_type, "brightness")) {
 452                 ret += setting_reset_display_brightness();
 453         }
 454         return ret;
 455 }
 456
 457 /*****/