src/view.c

   1 /*
   2  * Copyright (c) 2009-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Ecore.h>
  18 #include <feedback.h>
  19 #include <vconf.h>
  20 #include <vconf-keys.h>
  21
  22 #include "main.h"
  23 #include "_util_efl.h"
  24 #include "_util_log.h"
  25 #include "view.h"
  26 #include "control.h"
  27 #include "timer.h"
  28 #include "key_event.h"
  29 #include "sound.h"
  30 #include "tzsh_volume_service.h"
  31
  32 struct _view_s_info {
  33         Evas_Object *win;
  34         tzsh_h tzsh;
  35         tzsh_volume_service_h volume_service;
  36         Evas_Object *evas;
  37         Evas_Object *ly_outer;
  38         Evas_Object *icon_volume;
  39         Evas_Object *icon_setting;
  40         Evas_Object *slider;
  41         Evas_Object *warning_popup;
  42
  43         Evas_Object *lockscreen_splash;
  44
  45         Evas_Object *ao_settings;
  46
  47         Eina_Bool is_registered_callback;
  48         Eina_Bool is_slider_touching;
  49         Eina_Bool is_warning_displayed;
  50         sound_type_e pre_sound_type;
  51 };
  52 static struct _view_s_info view_info = {
  53         .win = NULL,
  54         .tzsh = NULL,
  55         .volume_service = NULL,
  56         .evas = NULL,
  57         .ly_outer = NULL,
  58         .icon_volume = NULL,
  59         .icon_setting = NULL,
  60         .slider = NULL,
  61         .warning_popup = NULL,
  62
  63         .lockscreen_splash = NULL,
  64
  65         .ao_settings = NULL,
  66
  67         .is_registered_callback = EINA_FALSE,
  68         .is_slider_touching = EINA_FALSE,
  69         .is_warning_displayed = EINA_FALSE,
  70         .pre_sound_type = SOUND_TYPE_RINGTONE
  71 };
  72
  73 static void _button_cb(void *data, Evas_Object *obj, void *event_info);
  74 static void _button_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
  75 static void _app_control_error_check(int ret);
  76 static void _hide_launcher(void *data, Evas_Object *obj, const char *emission, const char *source);
  77 static void _slider_stop_cb(void *data, Evas_Object *obj, void *event_info);
  78 static void _slider_start_cb(void *data, Evas_Object *obj, void *event_info);
  79 static void _slider_changed_cb(void *data, Evas_Object *obj, void *event_info);
  80 static Evas_Object* _slider_make();
  81 static Evas_Object* _volume_icon_make();
  82 static Evas_Object* _setting_icon_make();
  83
  84 Evas_Object* volume_view_win_get(void)
  85 {
  86         return view_info.win;
  87 }
  88
  89 tzsh_h volume_view_tzsh_get(void)
  90 {
  91         return view_info.tzsh;
  92 }
  93
  94 tzsh_volume_service_h volume_view_service_get(void)
  95 {
  96         return view_info.volume_service;
  97 }
  98
  99 Evas_Object* volume_view_evas_get(void)
 100 {
 101         return view_info.evas;
 102 }
 103
 104 Evas_Object* volume_view_outer_layout_get(void)
 105 {
 106         return view_info.ly_outer;
 107 }
 108
 109 Evas_Object* volume_view_icon_volume_get(void)
 110 {
 111         return view_info.icon_volume;
 112 }
 113
 114 Evas_Object* volume_view_icon_setting_get(void)
 115 {
 116         return view_info.icon_setting;
 117 }
 118
 119 Evas_Object* volume_view_slider_get(void)
 120 {
 121         return view_info.slider;
 122 }
 123
 124 Evas_Object* volume_view_warning_popup_get(void)
 125 {
 126         return view_info.warning_popup;
 127 }
 128
 129 Eina_Bool volume_view_is_registered_callback_get(void)
 130 {
 131         return view_info.is_registered_callback;
 132 }
 133
 134 Eina_Bool volume_view_is_slider_touching_get(void)
 135 {
 136         return view_info.is_slider_touching;
 137 }
 138
 139 sound_type_e volume_view_pre_sound_type_get(void)
 140 {
 141         return view_info.pre_sound_type;
 142 }
 143
 144 volume_error_e volume_view_set_default_slider(){
 145         Evas_Object *slider = volume_view_slider_get();
 146         elm_object_style_set(slider, "default");
 147         return VOLUME_ERROR_OK;
 148 }
 149
 150 volume_error_e volume_view_set_warning_slider(){
 151         Evas_Object *slider = volume_view_slider_get();
 152         elm_object_style_set(slider, "warning");
 153         Edje_Message_Float_Set *msg = alloca(sizeof(Edje_Message_Float_Set) + (sizeof(double)));
 154         msg->count = 1;
 155         msg->val[0] = 0.66;
 156         edje_object_message_send(elm_layout_edje_get(slider), EDJE_MESSAGE_FLOAT_SET, 0, msg);
 157
 158         return VOLUME_ERROR_OK;
 159 }
 160
 161 int volume_mute_toggle_set()
 162 {
 163         sound_type_e sound_type = volume_control_get_sound_type_at_show();
 164         _D("sound type at show : %d", sound_type);
 165
 166         int sound = volume_sound_vconf_status_get(TYPE_VCONF_SOUND_STATUS);
 167         _D("sound status : %d", sound);
 168
 169         int vibration = volume_sound_vconf_status_get(TYPE_VCONF_VIBRATION_STATUS);
 170         _E("vibration : %d", vibration);
 171
 172         if (sound == 1 || vibration == 1) {
 173                 volume_sound_vconf_status_set(TYPE_VCONF_SOUND_STATUS, 0);
 174                 volume_sound_vconf_status_set(TYPE_VCONF_VIBRATION_STATUS, 0);
 175
 176                 if(VOLUME_ERROR_OK != volume_view_slider_value_set(0))
 177                         _E("Failed to set slider value");
 178
 179                 return 0;
 180         }
 181         else {
 182                 volume_sound_vconf_status_set(TYPE_VCONF_SOUND_STATUS, 1);
 183                 volume_sound_vconf_status_set(TYPE_VCONF_VIBRATION_STATUS, 0);
 184
 185                 int val = volume_sound_level_get(sound_type);
 186                 retv_if(val == -1, 0);
 187
 188                 if (val == 0) {
 189                         if (VOLUME_ERROR_OK != volume_view_slider_value_set(1))
 190                                 _E("Failed to set slider value");
 191                         volume_sound_level_set(sound_type, 1);
 192                 } else {
 193                         if (VOLUME_ERROR_OK != volume_view_slider_value_set(val))
 194                                 _E("Failed to set slider value");
 195                 }
 196
 197                 return 1;
 198         }
 199 }
 200
 201 volume_error_e volume_view_change_slider_by_type(sound_type_e type, bool bt_opened, int earphone_connected)
 202 {
 203         _D("Slider change for state: %d", type);
 204         int ret = 0;
 205         int step = 0;
 206
 207         if (type == SOUND_TYPE_MEDIA && (bt_opened || earphone_connected)) {
 208                 _D("=Change to warning slider=");
 209                 elm_object_style_set(view_info.slider, "warning");
 210         } else {
 211                 _D("=Change to normal slider=");
 212                 elm_object_style_set(view_info.slider, "default");
 213         }
 214
 215         ret = sound_manager_get_max_volume(type, &step);
 216         if (ret < 0) {
 217                 _E("Failed to get max volume for sound_type: %d", type);
 218                 return VOLUME_ERROR_FAIL;
 219         }
 220         _D("Sound type: %d, max: %d", type, step);
 221
 222         elm_slider_min_max_set(view_info.slider, 0, step);
 223
 224         view_info.pre_sound_type = type;
 225
 226         return VOLUME_ERROR_OK;
 227 }
 228
 229 static void _cancel_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 230 {
 231         volume_view_destroy_warning_popup();
 232 }
 233
 234 static void _ok_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 235 {
 236         _D("Increase button is clicked");
 237         volume_control_set_safety_limit(EINA_FALSE);
 238         volume_control_set_time_for_safety_limit();
 239
 240         volume_view_destroy_warning_popup();
 241 }
 242
 243 volume_error_e volume_view_open_warning_popup(void)
 244 {
 245         Evas_Object *popup = NULL;
 246         Evas_Object *cancel_btn = NULL;
 247         Evas_Object *ok_btn = NULL;
 248
 249         popup = elm_popup_add(view_info.win);
 250         elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 251         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 252         elm_object_text_set(popup, "Listening at a high volume for a long time may damage your hearing. The volume will be increaed above safe levels.");
 253
 254         cancel_btn = elm_button_add(popup);
 255         elm_object_style_set(cancel_btn, "popup");
 256         elm_object_text_set(cancel_btn, "Cancel");
 257         elm_object_part_content_set(popup, "button2", cancel_btn);
 258         evas_object_smart_callback_add(cancel_btn, "clicked", _cancel_clicked_cb, popup);
 259
 260         ok_btn = elm_button_add(popup);
 261         elm_object_style_set(ok_btn, "popup");
 262         elm_object_text_set(ok_btn, "Increase");
 263         elm_object_part_content_set(popup, "button1", ok_btn);
 264         evas_object_smart_callback_add(ok_btn, "clicked", _ok_clicked_cb, popup);
 265
 266         view_info.warning_popup = popup;
 267         evas_object_show(popup);
 268
 269         return VOLUME_ERROR_OK;
 270 }
 271
 272 void volume_view_destroy_warning_popup(void)
 273 {
 274         _D("Destroy warning popup");
 275         if (VOLUME_ERROR_OK != volume_view_send_warning_signal(EINA_FALSE)) {
 276                 _E("Failed to set warning status");
 277         }
 278
 279         evas_object_del(view_info.warning_popup);
 280         view_info.warning_popup = NULL;
 281
 282         if (VOLUME_ERROR_OK != volume_control_hide_view())
 283                 _E("Failed to close volume");
 284         if (VOLUME_ERROR_OK != volume_control_cache_flush())
 285                 _E("Failed to flush cache");
 286 }
 287
 288 volume_error_e volume_view_slider_value_set(int val)
 289 {
 290         _D("Slider value set : %d", val);
 291         retv_if(view_info.is_slider_touching, VOLUME_ERROR_FAIL);
 292         retv_if(val<0, VOLUME_ERROR_FAIL);
 293
 294         elm_slider_value_set(view_info.slider, val);
 295
 296         return VOLUME_ERROR_OK;
 297 }
 298
 299 void volume_view_volume_icon_set(sound_type_e sound_type, int sound, int vibration, bool bt_opened)
 300 {
 301         _D("Volume icon set");
 302         char *img = NULL;
 303
 304         if (sound == -1 || vibration == -1) {
 305                 img = IMG_VOLUME_ICON_MUTE;
 306                 _D("img : %s", img);
 307                 elm_image_file_set(view_info.icon_volume, EDJ_APP, img);
 308                 return;
 309         }
 310
 311         switch (sound_type)
 312         {
 313         case SOUND_TYPE_RINGTONE:
 314                 if (sound)
 315                         img = IMG_VOLUME_ICON;
 316                 else if (vibration)
 317                         img = IMG_VOLUME_ICON_VIB;
 318                 else
 319                         img = IMG_VOLUME_ICON_MUTE;
 320                 break;
 321         case SOUND_TYPE_MEDIA:
 322                 img = IMG_VOLUME_ICON_MEDIA;
 323                 break;
 324         case SOUND_TYPE_CALL:
 325                 if (bt_opened)
 326                         img = IMG_VOLUME_ICON_CALL;
 327                 else
 328                         img = IMG_VOLUME_ICON_CALL;
 329                 break;
 330         case SOUND_TYPE_NOTIFICATION:
 331                 if (sound)
 332                         img = IMG_VOLUME_ICON_NOTI;
 333                 else if(vibration)
 334                         img = IMG_VOLUME_ICON_NOTI_VIB;
 335                 else
 336                         img = IMG_VOLUME_ICON_NOTI_MUTE;
 337                 break;
 338         case SOUND_TYPE_ALARM:
 339                 img = IMG_VOLUME_ICON_MEDIA;
 340                 break;
 341         default:
 342                 img = IMG_VOLUME_ICON;
 343                 break;
 344         }
 345
 346         _D("img : %s", img);
 347         elm_image_file_set(view_info.icon_volume, EDJ_APP, img);
 348 }
 349
 350 void volume_view_setting_icon_set(const char *file)
 351 {
 352         _D("Setting icon image set");
 353         ret_if(!file);
 354
 355         Evas_Object *icon_setting = view_info.icon_setting;
 356         ret_if(!icon_setting);
 357
 358         if (EINA_TRUE != elm_image_file_set(icon_setting, EDJ_APP, file)) {
 359                 _E("Failed to set image file : %s, Group", EDJ_APP, file);
 360         };
 361 }
 362
 363 void volume_view_setting_icon_callback_add(void)
 364 {
 365         _D("Setting callback add");
 366         ret_if(view_info.is_registered_callback);
 367
 368         Evas_Object *icon_setting = view_info.icon_setting;
 369         ret_if(!icon_setting);
 370
 371         evas_object_event_callback_add(icon_setting, EVAS_CALLBACK_MOUSE_DOWN, _button_mouse_down_cb, NULL);
 372         evas_object_smart_callback_add(icon_setting, "clicked", _button_cb, NULL);
 373
 374         view_info.is_registered_callback = EINA_TRUE;
 375 }
 376
 377 void volume_view_setting_icon_callback_del(void)
 378 {
 379         _D("Setting callback del");
 380         ret_if(!view_info.is_registered_callback);
 381
 382         Evas_Object *icon_setting = view_info.icon_setting;
 383         ret_if(!icon_setting);
 384
 385         evas_object_smart_callback_del(icon_setting, "clicked", _button_cb );
 386         evas_object_event_callback_del(icon_setting, EVAS_CALLBACK_MOUSE_DOWN, _button_mouse_down_cb);
 387
 388         view_info.is_registered_callback = EINA_FALSE;
 389 }
 390
 391 Evas_Object *add_slider(Evas_Object *parent, int min, int max, int val)
 392 {
 393         retv_if(!parent, NULL);
 394         Evas_Object *slider = elm_slider_add(parent);
 395         retvm_if(!slider, NULL, "Failed to add slider");
 396
 397         elm_slider_horizontal_set(slider, EINA_TRUE);
 398         elm_slider_indicator_show_set(slider, EINA_FALSE);
 399         elm_slider_indicator_format_set(slider, "%.0f");
 400         evas_object_size_hint_weight_set(slider, EVAS_HINT_EXPAND, 0.0);
 401         evas_object_size_hint_align_set(slider, EVAS_HINT_FILL, 0.5);
 402         elm_slider_min_max_set(slider, min, max);
 403         elm_slider_value_set(slider, val);
 404
 405         return slider;
 406 }
 407
 408 volume_error_e volume_view_send_warning_signal(Eina_Bool warning)
 409 {
 410         if (warning) {
 411                 _D("Show warning popup, and hide volume popup");
 412                 elm_object_signal_emit(view_info.ly_outer, "show,warning", "bg");
 413         } else {
 414                 int current_angle = volume_control_get_current_angle();
 415                 _D("Current angle: %d", current_angle);
 416         switch(current_angle){
 417         case 90 :
 418         case 270 :
 419             _D("show,landscape");
 420             elm_object_signal_emit(view_info.ly_outer, "show,landscape", "bg");
 421             break;
 422         default :
 423             _D("show,portrait");
 424             elm_object_signal_emit(view_info.ly_outer, "show,portrait", "bg");
 425             break;
 426         }
 427         }
 428         return VOLUME_ERROR_OK;
 429 }
 430
 431 volume_error_e volume_view_window_show(sound_type_e type)
 432 {
 433         _D("Volume view window SHOW is [%p]", view_info.win);
 434
 435         elm_win_iconified_set(view_info.win, EINA_FALSE);
 436
 437         if (type == SOUND_TYPE_CALL) {
 438                 _D("Sound type is Call");
 439         } else {
 440                 volume_view_setting_icon_callback_add();
 441         }
 442
 443         return VOLUME_ERROR_OK;
 444 }
 445
 446 volume_error_e volume_view_window_hide(void)
 447 {
 448         _D("Volume view window HIDE");
 449         elm_win_iconified_set(view_info.win, EINA_TRUE);
 450         volume_view_setting_icon_callback_del();
 451
 452         return VOLUME_ERROR_OK;
 453 }
 454
 455 Evas_Object *add_layout(Evas_Object *parent, const char *file, const char *group)
 456 {
 457         retvm_if(!parent, NULL, "Invalid argument: parent is NULL\n");
 458         retvm_if(!file, NULL, "Invalid argument: file is NULL\n");
 459         retvm_if(!group, NULL, "Invalid argument: group is NULL\n");
 460
 461         Evas_Object *eo = elm_layout_add(parent);
 462         retvm_if(!eo, NULL, "Failed to add layout\n");
 463
 464         int r = -1;
 465         r = elm_layout_file_set(eo, file, group);
 466         if (!r) {
 467                 _E("Failed to set file[%s]\n", file);
 468                 evas_object_del(eo);
 469                 return NULL;
 470         }
 471
 472         evas_object_size_hint_weight_set(eo, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 473         evas_object_show(eo);
 474
 475         return eo;
 476 }
 477
 478 void _connect_to_wm(Evas_Object *win)
 479 {
 480         _D("Mack connection with window manager");
 481
 482         tzsh_window tz_win;
 483
 484         view_info.tzsh = tzsh_create(TZSH_TOOLKIT_TYPE_EFL);
 485         if (!view_info.tzsh) {
 486                 _E("Failed to get connection to Tizen window manager");
 487         }
 488
 489         tz_win = elm_win_window_id_get(win);
 490         if (!tz_win) {
 491                 _E("Failed to get Tizen window manager");
 492         }
 493
 494         view_info.volume_service = tzsh_volume_service_create(view_info.tzsh, tz_win);
 495         if (!view_info.volume_service) {
 496                 _E("Failed to get volume service");
 497         }
 498 }
 499
 500 static void _down_for_hide(void *data, Evas_Object *obj, const char* emission, const char* source)
 501 {
 502         LOGD("Down for HIDE");
 503
 504         volume_control_hide_view();
 505 }
 506
 507 volume_error_e volume_view_layout_create(Evas_Object *win)
 508 {
 509         LOGD("Layout create");
 510
 511         retv_if(!win, VOLUME_ERROR_FAIL);
 512
 513         Evas_Object *ly_outer = add_layout(win, EDJ_APP, "volume_layout");
 514         retv_if(!ly_outer, VOLUME_ERROR_FAIL);
 515         elm_win_resize_object_add(win, ly_outer);
 516         elm_object_signal_callback_add(ly_outer, "hide,popup", "event", _hide_launcher, NULL);
 517         view_info.ly_outer = ly_outer;
 518
 519         /* make setting icon */
 520         Evas_Object *icon_setting = _setting_icon_make();
 521         retv_if(!icon_setting, VOLUME_ERROR_FAIL);
 522         elm_object_part_content_set(ly_outer, "ic_setting", icon_setting);
 523         view_info.icon_setting = icon_setting;
 524
 525         /* make volume icon */
 526         Evas_Object *icon_volume = _volume_icon_make();
 527         retv_if(!icon_volume, VOLUME_ERROR_FAIL);
 528         elm_object_part_content_set(ly_outer, "ic_sound", icon_volume);
 529         view_info.icon_volume = icon_volume;
 530
 531         /* make slider */
 532         Evas_Object *slider = _slider_make();
 533         retv_if(!slider, VOLUME_ERROR_FAIL);
 534         view_info.slider = slider;
 535         elm_object_part_content_set(ly_outer, "sw.slider", slider);
 536
 537         /* add callback for hide */
 538         elm_object_signal_callback_add(ly_outer, "hide,volume", "hide", _down_for_hide, NULL);
 539
 540         return VOLUME_ERROR_OK;
 541 }
 542
 543 static void _iconified_cb(void *data, Evas_Object *obj, void *event_info)
 544 {
 545         _D("ICONIFIED IS CALLED");
 546 }
 547
 548 Evas_Object *add_volume_window(const char *name)
 549 {
 550         Evas_Object *eo = NULL;
 551         Evas *evas = NULL;
 552         int x, y, w, h = 0;
 553
 554         eo = elm_win_add(NULL, name, ELM_WIN_NOTIFICATION);
 555         retv_if(!eo, NULL);
 556         evas = evas_object_evas_get(eo);
 557         retv_if(!evas, NULL);
 558         view_info.evas = evas;
 559
 560         elm_win_alpha_set(eo, EINA_TRUE);
 561         elm_win_title_set(eo, name);
 562         elm_win_borderless_set(eo, EINA_TRUE);
 563         ecore_evas_name_class_set(ecore_evas_ecore_evas_get(evas), "SYSTEM_POPUP", "SYSTEM_POPUP");
 564         elm_win_prop_focus_skip_set(eo, EINA_TRUE);
 565         elm_win_role_set(eo, "no-dim");
 566
 567         elm_win_screen_size_get(eo, &x, &y, &w, &h);
 568         _D("volume screen size => x: %d, y: %d, w: %d, h: %d", x, y, w, h);
 569
 570         evas_object_smart_callback_add(eo, "iconified", _iconified_cb, NULL);
 571
 572         return eo;
 573 }
 574
 575 static Eina_Bool _key_grab_cb(void *data)
 576 {
 577         int ret_up = 0;
 578         int ret_down = 0;
 579         Evas_Object *win = data;
 580
 581         _D("keygrab window is [%p]", win);
 582         ret_up = elm_win_keygrab_set(win, KEY_VOLUMEUP, 0, 0, 0, ELM_WIN_KEYGRAB_SHARED);
 583         _D("Result of volume up keygrab set : %d", ret_up);
 584         ret_down = elm_win_keygrab_set(win, KEY_VOLUMEDOWN, 0, 0, 0, ELM_WIN_KEYGRAB_SHARED);
 585         _D("Result of volume down keygrab set : %d", ret_down);
 586
 587         return EINA_FALSE;
 588 }
 589
 590 Evas_Object *volume_view_window_create(void)
 591 {
 592         Evas_Object *win = add_volume_window(PACKAGE);
 593         retv_if(!win, NULL);
 594         _D("window is [%p]", win);
 595
 596         view_info.win = win;
 597         _D("view_info.win is [%p]", view_info.win);
 598
 599         evas_object_show(win);
 600
 601         ecore_timer_add(1.0f, _key_grab_cb, win);
 602
 603         _connect_to_wm(win);
 604
 605         elm_win_iconified_set(win, EINA_TRUE);
 606
 607         return win;
 608 }
 609
 610 void _lock_sound_check(void)
 611 {
 612         int lcdoff_source = -1;
 613         int lock_sound = -1;
 614         int lock_type = -1;
 615
 616         if (vconf_get_int(VCONFKEY_PM_LCDOFF_SOURCE, &lcdoff_source) < 0) {
 617                 _E("Failed to get vconfkey : VCONFKEY_PM_LCDOFF_SOURCE");
 618                 return;
 619         }
 620         _D("lcd off source : %d", lcdoff_source);
 621
 622         if (lcdoff_source != VCONFKEY_PM_LCDOFF_BY_POWERKEY) {
 623                 _E("Should not play lock sound");
 624                 return;
 625         }
 626
 627         if (vconf_get_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, &lock_sound) < 0) {
 628                 _E("Failed to get vconfkey : VCONFKEY_SETAPPL_SOUND_LOCK_BOOL");
 629                 return;
 630         }
 631         _D("lock sound : %d", lock_sound);
 632
 633         if (lock_sound) {
 634                 if (vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &lock_type) < 0) {
 635                         _E("Failed to get vconfkey : VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT");
 636                         lock_type = 0;
 637                 }
 638                 _D("lock type : %d", lock_type);
 639
 640                 feedback_play_type(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_LOCK);
 641         }
 642 }
 643
 644 Evas_Object* show_lockscreen_splash(const char* bg_path)
 645 {
 646         _D(" ");
 647
 648         retv_if(bg_path == NULL, NULL);
 649
 650         if (view_info.lockscreen_splash) {
 651                 _E("There is remain fake_bg : remove old one");
 652                 evas_object_del(view_info.lockscreen_splash);
 653                 view_info.lockscreen_splash = NULL;
 654         }
 655
 656         /* Check Lock Sound */
 657         _lock_sound_check();
 658
 659         /* hide volume window */
 660         if(VOLUME_ERROR_OK != volume_view_window_hide())
 661                 _E("Failed to hide window");
 662
 663         Evas_Object *win_splash = elm_win_add(NULL,"lockscreen_splash", ELM_WIN_NOTIFICATION);
 664
 665         if (!win_splash) {
 666                 _E("Failed to add splash window");
 667                 return NULL;
 668         }
 669
 670         _D("Splash window created");
 671
 672         Evas_Object *bg = elm_bg_add(win_splash);
 673         if (!bg) {
 674                 _D("Failed to get background");
 675                 evas_object_del(win_splash);
 676                 return NULL;
 677         }
 678
 679         elm_win_resize_object_add(win_splash, bg);
 680         elm_bg_file_set(bg, bg_path, NULL);
 681         evas_object_show(bg);
 682
 683         evas_object_show(win_splash);
 684
 685         _D("Splash window shown");
 686
 687         view_info.lockscreen_splash = win_splash;
 688
 689         return win_splash;
 690 }
 691
 692 volume_error_e hide_lockscreen_splash(void)
 693 {
 694         _D(" ");
 695
 696         if (!view_info.lockscreen_splash) {
 697                 _E("No splash window found");
 698                 return VOLUME_ERROR_FAIL;
 699         }
 700
 701         evas_object_del(view_info.lockscreen_splash);
 702         view_info.lockscreen_splash = NULL;
 703         _D("Splash window closed");
 704
 705         return VOLUME_ERROR_OK;
 706 }
 707 static void _slider_start_cb(void *data, Evas_Object *obj, void *event_info)
 708 {
 709         view_info.is_slider_touching = EINA_TRUE;
 710
 711         volume_timer_del(TYPE_TIMER_POPUP);
 712
 713         volume_timer_add(0.2, TYPE_TIMER_SLIDER);
 714 }
 715
 716 static void _slider_changed_cb(void *data, Evas_Object *obj, void *event_info)
 717 {
 718         volume_timer_del(TYPE_TIMER_POPUP);
 719
 720         double val = 0;
 721
 722         sound_type_e sound_type = volume_control_get_sound_type_at_show();
 723         _D("sound type at show : %d", sound_type);
 724
 725         val = elm_slider_value_get(view_info.slider);
 726         val += 0.5;
 727         _D("slider value : %d", val);
 728
 729         if (view_info.is_slider_touching)
 730                 return;
 731
 732         volume_sound_change_set((int)val);
 733
 734         if (!volume_key_event_is_pressing_get()) {
 735                 volume_timer_add(3.0, TYPE_TIMER_POPUP);
 736                 return;
 737         }
 738
 739         if (!view_info.is_slider_touching) {
 740                 volume_timer_add(3.0, TYPE_TIMER_POPUP);
 741                 return;
 742         }
 743 }
 744
 745 static void _slider_stop_cb(void *data, Evas_Object *obj, void *event_info)
 746 {
 747         view_info.is_slider_touching = EINA_FALSE;
 748
 749         volume_timer_del(TYPE_TIMER_SLIDER);
 750
 751         Evas_Object *slider = volume_view_slider_get();
 752         ret_if(slider == NULL);
 753
 754         double val = 0;
 755
 756         val = elm_slider_value_get(slider);
 757         val += 0.5;
 758         _D("slider value : %d", (int)val);
 759
 760         volume_sound_change_set((int)val);
 761
 762         volume_timer_add(3.0, TYPE_TIMER_POPUP);
 763 }
 764
 765 static void _hide_launcher(void *data, Evas_Object *obj, const char *emission, const char *source)
 766 {
 767         evas_object_hide(view_info.win);
 768 }
 769
 770 static void _button_mouse_down_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 771 {
 772         elm_object_signal_emit(view_info.ly_outer, "pressed", "setting");
 773 }
 774
 775 static void _app_control_error_check(int ret)
 776 {
 777         if (ret != APP_CONTROL_ERROR_NONE) {
 778                 switch (ret)
 779                 {
 780                 case APP_CONTROL_ERROR_INVALID_PARAMETER :
 781                         _E("error : APP_CONTROL_ERROR_INVALID_PARAMETER");
 782                         break;
 783                 case APP_CONTROL_ERROR_OUT_OF_MEMORY :
 784                         _E("error : APP_CONTROL_ERROR_OUT_OF_MEMORY");
 785                         break;
 786                 case APP_CONTROL_ERROR_APP_NOT_FOUND :
 787                         _E("error : APP_CONTROL_ERROR_APP_NOT_FOUND");
 788                         break;
 789                 case APP_CONTROL_ERROR_LAUNCH_REJECTED :
 790                         _E("error : APP_CONTROL_ERROR_LAUNCH_REJECTED");
 791                         break;
 792                 default :
 793                         _E("error : %d", ret);
 794                         break;
 795                 }
 796         }
 797 }
 798
 799 static void _button_cb(void *data, Evas_Object *obj, void *event_info)
 800 {
 801         int ret = -1;
 802         app_control_h app_setting;
 803
 804         if (evas_object_visible_get(view_info.win)) {
 805                 volume_timer_del(TYPE_TIMER_POPUP);
 806
 807                 /* Send Launch Request to Setting */
 808                 ret = app_control_create(&app_setting);
 809                 _app_control_error_check(ret);
 810
 811                 ret = app_control_set_app_id(app_setting, "org.tizen.setting.volume");
 812                 _app_control_error_check(ret);
 813
 814                 ret = app_control_send_launch_request(app_setting, NULL, NULL);
 815                 _app_control_error_check(ret);
 816
 817                 if (VOLUME_ERROR_OK != volume_control_pause())
 818                         _E("Failed to pause volume");
 819
 820                 app_control_destroy(app_setting);
 821         }
 822 }
 823
 824 static Evas_Object* _setting_icon_make()
 825 {
 826         _D("Setting ICON make");
 827         Evas_Object *icon_setting = elm_icon_add(view_info.ly_outer);
 828         retv_if(!icon_setting, NULL);
 829
 830         evas_object_size_hint_aspect_set(icon_setting, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 831         elm_image_resizable_set(icon_setting, EINA_TRUE, EINA_TRUE);
 832
 833         view_info.icon_setting = icon_setting;
 834
 835         volume_view_setting_icon_set(IMG_VOLUME_ICON_SETTINGS);
 836         evas_object_show(icon_setting);
 837
 838         return icon_setting;
 839 }
 840
 841 static Evas_Object* _volume_icon_make()
 842 {
 843         Evas_Object *icon_volume = elm_icon_add(view_info.ly_outer);
 844         retv_if(!icon_volume, NULL);
 845
 846         evas_object_size_hint_aspect_set(icon_volume, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 847         elm_image_resizable_set(icon_volume, EINA_TRUE, EINA_TRUE);
 848         evas_object_show(icon_volume);
 849
 850         return icon_volume;
 851 }
 852
 853 static Evas_Object* _slider_make()
 854 {
 855         _D("Volume Slider Make");
 856         sound_type_e sound_type = volume_control_get_sound_type_at_show();
 857         _D("sound type at show : %d", sound_type);
 858
 859         int sound_step = volume_sound_sound_manager_step_get(sound_type);
 860         _D("sound step : %d", sound_step);
 861
 862         int sound_val = volume_sound_level_get(sound_type);
 863         if (sound_val == -1) {
 864                 _E("Failed to get volume level");
 865                 sound_val = 0;
 866         }
 867         _D("sound value : %d", sound_val);
 868
 869         Evas_Object *slider = add_slider(view_info.ly_outer, 0, sound_step, sound_val);
 870         retv_if(!slider, NULL);
 871         evas_object_smart_callback_add(slider, "slider,drag,start", _slider_start_cb, NULL);
 872         evas_object_smart_callback_add(slider, "changed", _slider_changed_cb, NULL);
 873         evas_object_smart_callback_add(slider, "slider,drag,stop", _slider_stop_cb, NULL);
 874
 875         return slider;
 876 }
 877