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