src/setting-volume.c

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  *  Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 <vconf.h>
  18 #include <vconf-keys.h>
  19
  20 #include "setting-volume.h"
  21 #include "setting_control_haptic.h"
  22 #include "setting-common-sound.h"
  23 #include "util.h"
  24
  25
  26 static struct _volume_menu_item volume_menu_its[] = {
  27         { "IDS_ST_BUTTON_MULTIMEDIA",                   _gl_multimedia_cb   },
  28         { "IDS_ST_HEADER_RINGTONES_ABB",                _gl_ringtone_cb     },
  29         { "IDS_ST_BUTTON_NOTIFICATIONS",                _gl_notification_cb },
  30         { "IDS_ST_BODY_SYSTEM_M_VOLUME_ABB",    _gl_system_cb       },
  31         { NULL, NULL }
  32 };
  33
  34 static void _set_volumn(sound_type_e type, int volume_index, char *vconf_key);
  35 static void _change_to_vibrate_mode();
  36 static void vibrate_vconf_changed_cb(keynode_t *key, void *data);
  37 static void sound_vconf_changed_cb(keynode_t *key, void *data);
  38 static void _play_sound_all_type(int sound_type, float volume);
  39 static void _update_volume_circle(Evas_Object *spiner);
  40
  41
  42 static int is_changing_level_by_vconf = 0;
  43 static int is_changed = 0;
  44 static int is_myself_changing = 0;
  45 static int is_myself_ringtone_changing = 0;
  46 static int is_play_ringtone_sound = 0;
  47
  48 static int is_sound_changed = 0;
  49 static int is_vibrate_changed = 0;
  50 static int is_play_media_sound = 0;
  51
  52
  53
  54 void _initialize_volume()
  55 {
  56         volume_index = 0;
  57         original_volume = 0;
  58         is_wav_playing_vol = SOUND_STATE_STOP;
  59         sound_id_vol = -1;
  60         is_changed = 0;
  61         is_changing_level_by_vconf = 0;
  62         is_myself_changing = 0;
  63         is_myself_ringtone_changing = 0;
  64
  65         is_sound_changed = 0;
  66         is_vibrate_changed = 0;
  67         is_play_media_sound = 0;
  68
  69         curr_sound_type = SOUND_TYPE_RINGTONE;
  70
  71         if (is_created_player()) {
  72                 _close_player(NULL, SOUND_TYPE_RINGTONE);
  73         }
  74 }
  75
  76 void _clear_volume_cb(void *data , Evas *e, Evas_Object *obj, void *event_info)
  77 {
  78         _clear_volume_resources();
  79
  80         return;
  81 }
  82
  83 static void stop_wav()
  84 {
  85         if (is_wav_playing_vol == SOUND_STATE_PLAY) {
  86                 DBG("Setting - sound id : %d", sound_id_vol);
  87
  88                 wav_player_stop(sound_id_vol);
  89                 is_wav_playing_vol = SOUND_STATE_STOP;
  90                 sound_id_vol = -1;
  91         }
  92 }
  93
  94 void _stop_all_volume_sound()
  95 {
  96         DBG("Setting - stop all volume sound.");
  97
  98         if (is_created_player()) {
  99                 _close_player(NULL, curr_sound_type);
 100         }
 101
 102         stop_wav();
 103 }
 104
 105 void _clear_volume_resources()
 106 {
 107         DBG("Setting - _clear_volume_resources()");
 108
 109         if (is_created_player()) {
 110                 _close_player(NULL, curr_sound_type);
 111         }
 112
 113         stop_wav();
 114
 115         g_ad = NULL;
 116         g_volume_spinner = NULL;
 117         is_myself_changing = 0;
 118         is_myself_ringtone_changing = 0;
 119         is_sound_changed = is_vibrate_changed = 0;
 120 }
 121
 122 static void _update_volume_popup_for_changing_sound_mode()
 123 {
 124         DBG("_update_volume_popup_for_changing_sound_mode is called!!");
 125
 126         int temp_volume_index = 0;
 127
 128         is_sound_changed = is_vibrate_changed = 0;
 129
 130         if (g_volume_spinner) {
 131                 is_changing_level_by_vconf = 1;
 132
 133                 int sound_mode = get_sound_mode();
 134
 135                 if (sound_mode == SOUND_MODE_VIBRATE) {
 136                         DBG("Setting - vibrate!!!");
 137
 138                         if (curr_sound_type == SOUND_TYPE_RINGTONE) {
 139                                 volume_index = 0;
 140                         }
 141                         elm_spinner_value_set(g_volume_spinner, 0);
 142                         _update_volume_circle(g_volume_spinner);
 143
 144                         _stop_all_volume_sound();
 145
 146                         edje_object_signal_emit(elm_layout_edje_get(g_volume_spinner), "elm,spinner,min", "elm");
 147                         edje_object_part_drag_value_set(elm_layout_edje_get(g_volume_spinner), "elm.dragable.slider", 0, 0);
 148                         edje_object_signal_emit(elm_layout_edje_get(g_volume_spinner), "elm,spinner,vibrate", "elm");
 149
 150                         if (curr_sound_type == SOUND_TYPE_NOTIFICATION ||
 151                                 curr_sound_type == SOUND_TYPE_SYSTEM) {
 152                                 DBG("current_sound_type!!");
 153
 154                                 elm_object_disabled_set(g_volume_spinner, EINA_TRUE);
 155                         }
 156                 } else if (sound_mode == SOUND_MODE_SOUND) {
 157                         DBG("Setting - Sound!!!");
 158
 159                         sound_manager_get_volume(curr_sound_type, &volume_index);
 160
 161                         DBG("volume_index !!!!!!  --------------   %d", volume_index);
 162
 163                         if (volume_index != 0) {
 164                                 elm_spinner_value_set(g_volume_spinner, volume_index);
 165
 166                                 _update_volume_circle(g_volume_spinner);
 167
 168                                 elm_object_disabled_set(g_volume_spinner, EINA_FALSE);
 169                         }
 170                 } else {
 171                         DBG("Setting - Mute!!!");
 172
 173                         if (curr_sound_type == SOUND_TYPE_NOTIFICATION ||
 174                                 curr_sound_type == SOUND_TYPE_SYSTEM) {
 175                                 elm_object_disabled_set(g_volume_spinner, EINA_FALSE);
 176
 177                                 edje_object_signal_emit(elm_layout_edje_get(g_volume_spinner), "elm,spinner,min", "elm");
 178                                 edje_object_part_drag_value_set(elm_layout_edje_get(g_volume_spinner), "elm.dragable.slider", 0, 0);
 179
 180                                 elm_object_disabled_set(g_volume_spinner, EINA_TRUE);
 181                         } else if (curr_sound_type == SOUND_TYPE_RINGTONE) {
 182                                 _stop_all_volume_sound();
 183
 184                                 if (curr_sound_type == SOUND_TYPE_RINGTONE) {
 185                                         volume_index = 0;
 186                                 }
 187                                 elm_spinner_value_set(g_volume_spinner, 0);
 188                                 _update_volume_circle(g_volume_spinner);
 189
 190                                 edje_object_signal_emit(elm_layout_edje_get(g_volume_spinner), "elm,spinner,min", "elm");
 191                                 edje_object_part_drag_value_set(elm_layout_edje_get(g_volume_spinner), "elm.dragable.slider", 0, 0);
 192                         }
 193                 }
 194         }
 195 }
 196
 197 static void sound_vconf_changed_cb(keynode_t *key, void *data)
 198 {
 199         DBG("Setting - sound_vconf_changed_cb() is called!!");
 200
 201         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 202                 return;
 203         }
 204
 205         if (is_myself_changing) {
 206                 DBG("Setting - is_myself_changing is called!!");
 207                 is_myself_changing = 0;
 208                 return;
 209         }
 210
 211         is_sound_changed = 1;
 212
 213         if (is_sound_changed && is_vibrate_changed) {
 214                 _update_volume_popup_for_changing_sound_mode();
 215         }
 216 }
 217
 218 static void vibrate_vconf_changed_cb(keynode_t *key, void *data)
 219 {
 220         DBG("Setting - vibrate_vconf_changed_cb() is called!!");
 221
 222         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 223                 return;
 224         }
 225
 226         if (is_myself_changing) {
 227                 DBG("Setting - is_myself_changing is called!!");
 228                 is_myself_changing = 0;
 229                 return;
 230         }
 231
 232         is_vibrate_changed = 1;
 233
 234         if (is_sound_changed && is_vibrate_changed) {
 235                 _update_volume_popup_for_changing_sound_mode();
 236         }
 237 }
 238
 239 static void pm_state_vconf_changed_cb_for_volume(keynode_t *key, void *data)
 240 {
 241         DBG("Setting - pm_state_vconf_changed_cb_for_volume() is called!");
 242
 243         int pm_state = 0;
 244         vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
 245
 246         if (pm_state == VCONFKEY_PM_STATE_LCDOFF) {
 247                 DBG("Setting - LCD Off!! stop sound!");
 248                 _stop_all_volume_sound();
 249         }
 250 }
 251
 252 static void _rigngtone_volume_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
 253 {
 254         DBG("Setting - _rigngtone_volume_changed_cb() is called!");
 255
 256         if (type != SOUND_TYPE_RINGTONE) {
 257                 DBG("Setting - sound_type is not media!!");
 258                 return;
 259         }
 260
 261         if (is_myself_ringtone_changing) {
 262                 is_myself_ringtone_changing = 0;
 263                 return;
 264         }
 265
 266         if (g_volume_spinner) {
 267                 volume_index = volume;
 268
 269                 DBG("Setting - Ringtone volume: %d", volume_index);
 270
 271                 is_play_ringtone_sound = 1;
 272
 273                 elm_spinner_value_set(g_volume_spinner, volume_index);
 274         }
 275 }
 276
 277 static void _media_volume_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
 278 {
 279         DBG("Setting - _media_volume_changed_cb() is called!");
 280
 281         if (type == SOUND_TYPE_RINGTONE) {
 282                 DBG("Setting - sound_type is ringtone!!");
 283                 return;
 284         }
 285
 286         if (is_myself_ringtone_changing) {
 287                 is_myself_ringtone_changing = 0;
 288                 return;
 289         }
 290
 291         if (volume_index == volume) {
 292                 DBG("Setting - Volume is same!! %d ---- %d ", volume_index, volume);
 293                 return;
 294         }
 295
 296         if (g_volume_spinner) {
 297                 volume_index = volume;
 298
 299                 DBG("Setting - Media volume: %d", volume_index);
 300
 301                 is_play_media_sound = 1;
 302
 303                 elm_spinner_value_set(g_volume_spinner, volume_index);
 304         }
 305 }
 306
 307 static void _gl_multimedia_cb(void *data, Evas_Object *obj, void *event_info)
 308 {
 309         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 310
 311         _show_multimedia_popup(data, obj, event_info);
 312 }
 313
 314 static void _gl_ringtone_cb(void *data, Evas_Object *obj, void *event_info)
 315 {
 316         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 317
 318         _show_ringtone_popup(data, obj, event_info);
 319 }
 320
 321 static void _gl_notification_cb(void *data, Evas_Object *obj, void *event_info)
 322 {
 323         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 324
 325         _show_notification_popup(data, obj, event_info);
 326 }
 327
 328 static void _gl_system_cb(void *data, Evas_Object *obj, void *event_info)
 329 {
 330         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 331
 332         _show_system_popup(data, obj, event_info);
 333 }
 334
 335 char *_gl_volume_title_get(void *data, Evas_Object *obj, const char *part)
 336 {
 337         char buf[1024] = {0,};
 338         Item_Data *id = data;
 339         int index = id->index;
 340         if (!strcmp(part, "elm.text")) {
 341                 snprintf(buf, sizeof(buf) - 1, "%s", _(volume_menu_its[index % VOLUMN_ITEM_COUNT].name));
 342                 index++;
 343         }
 344         return strdup(buf);
 345 }
 346
 347 static void _volumn_gl_del(void *data, Evas_Object *obj)
 348 {
 349         Item_Data *id = data;
 350         if (id)
 351                 free(id);
 352 }
 353
 354 #ifdef O_TYPE
 355 static char *
 356 _gl_menu_title_text_get(void *data, Evas_Object *obj, const char *part)
 357 {
 358         char buf[1024];
 359
 360         snprintf(buf, 1023, "%s", _("IDS_ST_OPT_VOLUME"));
 361         return strdup(buf);
 362 }
 363 #endif
 364
 365 Evas_Object *_create_volume_list(void *data)
 366 {
 367         appdata *ad = data;
 368         if (ad == NULL) {
 369                 DBG("%s", "_create_volume_list - appdata is null");
 370                 return NULL;
 371         }
 372         Evas_Object *genlist  = NULL;
 373         Elm_Object_Item *item = NULL;
 374         struct _volume_menu_item *menu_its = NULL;
 375         int idx = 0;
 376
 377         g_ad = ad;
 378
 379         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 380         itc->item_style = "1text";
 381         itc->func.text_get = _gl_volume_title_get;
 382         itc->func.del = _volumn_gl_del;
 383
 384         genlist = elm_genlist_add(ad->nf);
 385         elm_genlist_block_count_set(genlist, 14);
 386         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 387 #ifdef O_TYPE
 388         Evas_Object *circle_genlist = eext_circle_object_genlist_add(genlist, ad->circle_surface);
 389         eext_circle_object_genlist_scroller_policy_set(circle_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 390         eext_rotary_object_event_activated_set(circle_genlist, EINA_TRUE);
 391 #endif
 392
 393 #ifdef _CIRCLE
 394         Elm_Genlist_Item_Class *title_item = elm_genlist_item_class_new();
 395         title_item ->func.text_get = _gl_menu_title_text_get;
 396         title_item->item_style = "title";
 397         title_item->func.del = _volumn_gl_del;
 398
 399         elm_genlist_item_append(genlist, title_item, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 400
 401         elm_genlist_item_class_free(title_item);
 402 #endif
 403         menu_its = volume_menu_its;
 404
 405         for (idx = 0; idx < VOLUMN_ITEM_COUNT; idx++) {
 406                 Item_Data *id = calloc(sizeof(Item_Data), 1);
 407                 if (id) {
 408                         id->index = idx;
 409                         item = elm_genlist_item_append(
 410                                            genlist,                     /* genlist object */
 411                                            itc,                         /* item class */
 412                                            id,                      /* data */
 413                                            NULL,
 414                                            ELM_GENLIST_ITEM_NONE,
 415                                            menu_its[idx].func,  /* call back */
 416                                            ad);
 417                         id->item = item;
 418                 }
 419         }
 420 #ifdef _CIRCLE
 421         Elm_Genlist_Item_Class *padding = elm_genlist_item_class_new();
 422         padding->item_style = "padding";
 423         padding->func.del = _volumn_gl_del;
 424
 425         elm_genlist_item_append(genlist, padding, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 426         elm_genlist_item_class_free(padding);
 427 #endif
 428         elm_genlist_item_class_free(itc);
 429
 430         return genlist;
 431 }
 432
 433 static void change_sound_mode(int mode)
 434 {
 435         switch (mode) {
 436         case SOUND_MODE_SOUND:
 437                 DBG("Setting - Change sound mode to Sound!");
 438
 439                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 440                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 441                 break;
 442         case SOUND_MODE_VIBRATE:
 443                 DBG("Setting - Change sound mode to Sound!");
 444
 445                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 446                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 447                 break;
 448         case SOUND_MODE_MUTE:
 449                 DBG("Setting - Change sound mode to Sound!");
 450
 451                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 452                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 453                 break;
 454         }
 455 }
 456
 457 static void _set_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 458 {
 459         appdata *ad = data;
 460         if (ad == NULL)
 461                 return;
 462
 463         if (!is_changed) {
 464                 DBG("not changed");
 465                 elm_naviframe_item_pop(ad->nf);
 466                 return;
 467         }
 468 #if 1
 469         DBG("Setting - original volume : %d", original_volume);
 470
 471         char vconf_key[512] = {0,};
 472
 473         switch (curr_sound_type) {
 474         case SOUND_TYPE_MEDIA:
 475                 strcpy(vconf_key, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 476                 break;
 477         case SOUND_TYPE_RINGTONE:
 478                 strcpy(vconf_key, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
 479                 break;
 480         case SOUND_TYPE_SYSTEM:
 481                 strcpy(vconf_key, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
 482                 break;
 483         case SOUND_TYPE_NOTIFICATION:
 484                 strcpy(vconf_key, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
 485                 break;
 486         }
 487
 488         /* restore original vulume value */
 489         _set_volumn(curr_sound_type, original_volume, vconf_key);
 490 #endif
 491
 492         if (original_sound_mode != get_sound_mode()) {
 493                 /* restore sound mode */
 494                 change_sound_mode(original_sound_mode);
 495         }
 496
 497         /*original_volume = 0; */
 498
 499         if (is_created_player()) {
 500                 _close_player(ad, curr_sound_type);
 501         }
 502
 503         stop_wav();
 504
 505         elm_naviframe_item_pop(ad->nf);
 506 }
 507
 508 static Eina_Bool _back_volume_naviframe_cb(void *data, Elm_Object_Item *it)
 509 {
 510         DBG("Setting - _back_volume_naviframe_cb is called");
 511         DBG("Setting - original volume : %d", original_volume);
 512         DBG("Setting -    volume index : %d", volume_index);
 513
 514 #if 0
 515         char vconf_key[512] = {0,};
 516         switch (curr_sound_type) {
 517         case SOUND_TYPE_MEDIA:
 518                 strcpy(vconf_key, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 519                 break;
 520         case SOUND_TYPE_RINGTONE:
 521                 strcpy(vconf_key, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
 522                 break;
 523         case SOUND_TYPE_SYSTEM:
 524                 strcpy(vconf_key, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
 525                 break;
 526         case SOUND_TYPE_NOTIFICATION:
 527                 strcpy(vconf_key, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
 528                 break;
 529         }
 530
 531         _set_volumn(curr_sound_type,   volume_index, vconf_key);
 532 #endif
 533         if (original_sound_mode != get_sound_mode()) {
 534                 /* restore sound mode */
 535                 change_sound_mode(original_sound_mode);
 536         }
 537
 538         if (is_created_player()) {
 539                 _close_player(data, curr_sound_type);
 540         }
 541
 542         g_volume_spinner = NULL;
 543
 544         is_changed = 0;         /* initialize flag! */
 545
 546         stop_wav();
 547
 548         unregister_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume);
 549
 550         sound_manager_unset_volume_changed_cb();
 551
 552         /* Unregister sound mode vconf callback */
 553         unregister_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb);
 554         unregister_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb);
 555
 556         return EINA_TRUE;
 557 }
 558
 559 static void _set_volumn(sound_type_e type, int volume_index, char *vconf_key)
 560 {
 561         DBG("Setting - set_volume() is called!");
 562
 563         int err = -1;
 564         err = sound_manager_set_volume(type, volume_index);
 565
 566         /* save system vulume value */
 567         if (err == SOUND_MANAGER_ERROR_NONE) {
 568                 int vret = vconf_set_int(vconf_key, volume_index);
 569                 DBG(" ret = %d , %s :: %d ", vret, vconf_key, volume_index);
 570
 571                 if (curr_sound_type == SOUND_TYPE_RINGTONE) {
 572                         DBG("Ringtone volume is changed....!");
 573
 574                         if (volume_index == 0 && get_sound_mode() == SOUND_MODE_SOUND) {
 575                                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 576                                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 577                         } else if (volume_index > 0 && get_sound_mode() != SOUND_MODE_SOUND) {
 578                                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 579                                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 580                         }
 581                 } else {
 582                         DBG("current sound mode is %d, not type_ringtone", curr_sound_type);
 583                 }
 584         } else {
 585                 DBG("Setting - ringtone value is not saved...   %d", volume_index);
 586         }
 587 }
 588
 589 static void _set_multimedia_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 590 {
 591         appdata *ad = data;
 592         if (ad == NULL)
 593                 return;
 594
 595         if (!is_changed) {
 596                 DBG("not changed");
 597                 elm_naviframe_item_pop(ad->nf);
 598                 return;
 599         }
 600
 601         /* save multimedia vulume value */
 602         _set_volumn(SOUND_TYPE_MEDIA, volume_index, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 603
 604
 605         if (is_created_player()) {
 606                 _close_player(ad, curr_sound_type);
 607         }
 608
 609         stop_wav();
 610
 611         elm_naviframe_item_pop(ad->nf);
 612 }
 613
 614 static void _play_sound_all_type(int sound_type, float volume)
 615 {
 616         if (is_myself_ringtone_changing) {
 617                 DBG(" is_myself_ringtone_changing !!!!!!!!!!!");
 618
 619                 return;
 620         }
 621
 622         char buf[1024];
 623         const char *sound_path = NULL;
 624         int temp_volume_index = 0;
 625         switch (sound_type) {
 626         case SOUND_TYPE_RINGTONE:
 627                 temp_volume_index = volume_index;
 628
 629                 vconf_set_int(VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT, temp_volume_index);
 630                 vconf_set_int("db/setting/sound/call/rmd_ringtone_volume", temp_volume_index);  /* backup ringtone volume */
 631
 632                 sound_path = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 633                 if (sound_path) {
 634                         sprintf(buf, "%s", sound_path);
 635                 } else {
 636                         sprintf(buf, "%s", VCONFKEY_SETAPPL_CALL_RINGTONE_DEFAULT_PATH_STR);
 637                 }
 638
 639                 break;
 640         case SOUND_TYPE_MEDIA:
 641                 _set_volumn(sound_type, volume_index, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 642
 643                 sprintf(buf, "%s", SETTING_DEFAULT_MEDIA_TONE);
 644                 break;
 645         case SOUND_TYPE_NOTIFICATION:
 646                 vconf_set_int(VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT, volume_index);
 647                 temp_volume_index = volume_index;
 648
 649                 sound_path = vconf_get_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR);
 650                 if (sound_path) {
 651                         sprintf(buf, "%s", sound_path);
 652                 } else {
 653                         sprintf(buf, "%s", SETTING_DEFAULT_MSG_TONE);
 654                 }
 655                 break;
 656         case SOUND_TYPE_SYSTEM:
 657                 vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT, volume_index);
 658
 659                 sprintf(buf, "%s", SETTING_DEFAULT_SYS_TONE);
 660                 break;
 661         }
 662
 663         int err = -1;
 664
 665         if (sound_type == SOUND_TYPE_RINGTONE) {
 666                 DBG("Setting - ringtone safety volume!!");
 667                 DBG("Setting - real volume : %d", temp_volume_index);
 668
 669                 sound_manager_set_volume(sound_type, temp_volume_index);
 670         } else if (sound_type == SOUND_TYPE_NOTIFICATION) {
 671                 DBG("Setting - notification safety volume!!");
 672                 sound_manager_set_volume(sound_type, temp_volume_index);
 673         } else {
 674                 DBG("Setting - normal volume!! ----- volume_index : %d ", volume_index);
 675                 err = sound_manager_set_volume(sound_type, volume_index);
 676                 if (err != SOUND_MANAGER_ERROR_NONE) {
 677                         ERR("Setting - sound_manager_set_volume() is failed! : %d", err);
 678                 }
 679         }
 680
 681         if (sound_type == SOUND_TYPE_RINGTONE) {
 682                 if (!is_created_player() || is_player_paused()) {
 683                         play_sound(buf, volume, SOUND_TYPE_RINGTONE);
 684                         set_looping(TRUE);
 685                 }
 686                 is_myself_ringtone_changing = 1;
 687         } else if (sound_type == SOUND_TYPE_MEDIA) {
 688                 int music_state = 0;
 689                 int err = vconf_get_int("memory/private/org.tizen.w-music-player/player_state", &music_state);
 690
 691                 DBG("Setting - music state: %d, err: %d", music_state, err);
 692
 693                 if (music_state == VCONFKEY_MUSIC_PLAY) {
 694                         DBG("Setting - media is playing...");
 695                         return;
 696                 }
 697
 698                 if (!is_created_player() || is_player_paused()) {
 699                         play_sound(buf, volume, SOUND_TYPE_MEDIA);
 700                         set_looping(TRUE);
 701                 }
 702         }
 703
 704         else if (sound_type == SOUND_TYPE_SYSTEM) {
 705                 stop_wav();
 706
 707                 is_wav_playing_vol = SOUND_STATE_PLAY;
 708                 wav_player_start(buf, sound_type, NULL, NULL, &sound_id_vol);
 709                 return;
 710         } else if (sound_type == SOUND_TYPE_NOTIFICATION) {
 711                 play_sound(buf, 0.0, SOUND_TYPE_NOTIFICATION);
 712                 set_looping(FALSE);
 713
 714                 return;
 715         }
 716 }
 717
 718 static void _change_to_vibrate_mode()
 719 {
 720         DBG("Setting - _change_to_vibrate_mode() is called!");
 721
 722         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 723                 return;
 724         }
 725
 726         if (get_sound_mode() != SOUND_MODE_VIBRATE) {
 727                 DBG("Setting - Change sound mode to vibrate!");
 728
 729                 is_myself_changing = 1;
 730
 731                 _stop_all_volume_sound();
 732
 733                 _start_vibration(3, SETTING_VIB_STRONG_RATE, SETTING_DEFAULT_SYSTEM_HAPTIC_PREVIEW_VIB);
 734
 735                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 736                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 737         }
 738 }
 739
 740 static void _change_to_sound_mode()
 741 {
 742         DBG("Setting - _change_to_sound_mode() is called!");
 743
 744         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 745                 return;
 746         }
 747
 748         if (get_sound_mode() != SOUND_MODE_SOUND) {
 749                 DBG("Setting - Change sound mode to sound!");
 750
 751                 is_myself_changing = 1;
 752
 753                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 754                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 755         }
 756 }
 757
 758 static int sync_volume(int vconf_vol, int real_vol)
 759 {
 760         if (vconf_vol != real_vol)
 761                 return real_vol;
 762         return vconf_vol;
 763 }
 764
 765 static void _update_volume_circle(Evas_Object *spiner)
 766 {
 767         if (spiner == NULL)
 768                 return;
 769
 770         Evas_Coord w;
 771         double min, max, posx;
 772         int idx = (int) elm_spinner_value_get(spiner);
 773
 774         edje_object_part_geometry_get(elm_layout_edje_get(spiner), "center.image2", NULL, NULL, &w, NULL);
 775         elm_spinner_min_max_get(spiner, &min, &max);
 776
 777         if (idx == max)
 778                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,full", "elm");
 779         if (idx < max)
 780                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,default", "elm");
 781         if (idx == min) {
 782                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,min", "elm");
 783                 if (curr_sound_type != SOUND_TYPE_MEDIA && get_sound_mode() == SOUND_MODE_VIBRATE) {
 784                         edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,vibrate", "elm");
 785                 }
 786         }
 787         if (idx > min)
 788                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,normal", "elm");
 789
 790         posx = (double)(w / max) * idx;
 791
 792         edje_object_part_drag_value_set(elm_layout_edje_get(spiner), "elm.dragable.slider", posx, 0);
 793 }
 794
 795 static void _on_volume_spinner_change_cb(void *data, Evas_Object *obj, void *event_info)
 796 {
 797         DBG("Setting - _on_volume_spinner_change_cb() is called!");
 798
 799         if (is_changing_level_by_vconf) {
 800                 DBG("Setting - is_changing_level_by_vconf!!!!");
 801
 802                 is_changing_level_by_vconf = 0;
 803                 return;
 804         }
 805
 806         is_changed = 1; /* changed flag!! */
 807
 808         Evas_Coord w;
 809
 810         double min, max;
 811         int idx = (int) elm_spinner_value_get(obj);
 812
 813         volume_index = idx;
 814
 815         DBG("Setting - volume_index : %d", volume_index);
 816
 817         if (get_sound_mode() != SOUND_MODE_MUTE) {
 818                 if (!is_play_ringtone_sound) {
 819                         _play_sound_all_type(curr_sound_type, 0.0);
 820                 } else {
 821                         is_play_ringtone_sound = 0;
 822                 }
 823         }
 824
 825         edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL);
 826         elm_spinner_min_max_get(obj, &min, &max);
 827
 828         DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx);
 829
 830         if (idx == max) {
 831                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,full", "elm");
 832         }
 833         if (idx < max) {
 834                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,default", "elm");
 835         }
 836         if (idx == min) {
 837                 if (get_sound_mode() != SOUND_MODE_VIBRATE) {
 838                         _change_to_vibrate_mode();
 839                 }
 840                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 841                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,vibrate", "elm");
 842         }
 843         if (idx > min) {
 844                 if (get_sound_mode() == SOUND_MODE_MUTE) {
 845                         _change_to_vibrate_mode();
 846                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 847                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,vibrate", "elm");
 848
 849                         elm_spinner_value_set(obj, 0);
 850                 } else {
 851                         _change_to_sound_mode();
 852                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,normal", "elm");
 853                 }
 854         }
 855
 856         double posx = 0.0;
 857         if (get_sound_mode() == SOUND_MODE_MUTE) {
 858                 posx = 0;
 859         } else {
 860                 posx = (double)(w / max) * idx;
 861         }
 862
 863         edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0);
 864 }
 865
 866 static void _on_media_volume_spinner_change_cb(void *data, Evas_Object *obj, void *event_info)
 867 {
 868         DBG("Setting - _on_media_volume_spinner_change_cb() is called!");
 869
 870         if (curr_sound_type != SOUND_TYPE_MEDIA) {
 871                 if (is_changing_level_by_vconf) {
 872                         DBG("Setting - is_changing_level_by_vconf!!!!");
 873
 874                         is_changing_level_by_vconf = 0;
 875                         return;
 876                 }
 877         }
 878
 879         Evas_Coord w;
 880
 881         double min, max;
 882         int idx = (int) elm_spinner_value_get(obj);
 883
 884         is_changed = 1;         /* changed flag!! */
 885
 886         volume_index = idx;
 887
 888         DBG("Setting - volume_index : %d", volume_index);
 889
 890         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 891                 if (!is_play_media_sound) {
 892                         _play_sound_all_type(curr_sound_type, 0.0);
 893                         is_play_media_sound = 0;
 894                 } else {
 895                         is_play_media_sound = 0;
 896                 }
 897         } else {
 898                 _play_sound_all_type(curr_sound_type, 0.0);
 899         }
 900
 901         edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL);
 902         elm_spinner_min_max_get(obj, &min, &max);
 903
 904         DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx);
 905
 906         if (idx == max) {
 907                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,full", "elm");
 908         }
 909         if (idx < max) {
 910                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,default", "elm");
 911         }
 912         if (idx == min) {
 913                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 914         }
 915         if (idx > min) {
 916                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,normal", "elm");
 917         }
 918
 919         double posx = 0.0;
 920         posx = (double)(w / max) * idx;
 921
 922         edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0);
 923 }
 924
 925 #ifdef O_TYPE
 926 static void
 927 multimedia_value_changed(void *data, Evas_Object *obj, void *event_info)
 928 {
 929         DBG("Setting - multimedia_value_changed() is called!");
 930         char buf[PATH_MAX];
 931         Evas_Object *label = data;
 932
 933         snprintf(buf, sizeof(buf), "%.0lf", eext_circle_object_value_get(obj));
 934         DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>> Slider value = %s", buf);
 935         elm_object_text_set(label, buf);
 936
 937         if (curr_sound_type != SOUND_TYPE_MEDIA) {
 938                 if (is_changing_level_by_vconf) {
 939                         DBG("Setting - is_changing_level_by_vconf!!!!");
 940
 941                         is_changing_level_by_vconf = 0;
 942                         return;
 943                 }
 944         }
 945
 946         Evas_Coord w;
 947
 948         double min, max;
 949         int idx = (int) eext_circle_object_value_get(obj);
 950
 951         is_changed = 1;         /* changed flag!! */
 952
 953         volume_index = idx;
 954
 955         DBG("Setting - volume_index : %d", volume_index);
 956
 957         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 958                 if (!is_play_media_sound) {
 959                         _play_sound_all_type(curr_sound_type, 0.0);
 960                         is_play_media_sound = 0;
 961                 } else {
 962                         is_play_media_sound = 0;
 963                 }
 964         } else {
 965                 _play_sound_all_type(curr_sound_type, 0.0);
 966         }
 967
 968         double posx = 0.0;
 969         posx = (double)(w / max) * idx;
 970 }
 971
 972 static void
 973 ringtone_value_changed(void *data, Evas_Object *obj, void *event_info)
 974 {
 975         DBG("Setting - ringtone_value_changed() is called!");
 976         char buf[PATH_MAX];
 977         Evas_Object *label = data;
 978
 979         snprintf(buf, sizeof(buf), "%.0lf", eext_circle_object_value_get(obj));
 980         DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>> Slider value = %s", buf);
 981         if (get_sound_mode() == SOUND_MODE_SOUND) {
 982                 elm_object_text_set(label, buf);
 983
 984                 if (curr_sound_type != SOUND_TYPE_MEDIA) {
 985                         if (is_changing_level_by_vconf) {
 986                                 DBG("Setting - is_changing_level_by_vconf!!!!");
 987
 988                                 is_changing_level_by_vconf = 0;
 989                                 return;
 990                         }
 991                 }
 992
 993                 Evas_Coord w;
 994
 995                 double min, max;
 996                 int idx = (int) eext_circle_object_value_get(obj);
 997
 998                 is_changed = 1;         /* changed flag!! */
 999
1000                 volume_index = idx;
1001
1002                 DBG("Setting - volume_index : %d", volume_index);
1003
1004                 if (curr_sound_type == SOUND_TYPE_MEDIA) {
1005                         if (!is_play_media_sound) {
1006                                 _play_sound_all_type(curr_sound_type, 0.0);
1007                                 is_play_media_sound = 0;
1008                         } else {
1009                                 is_play_media_sound = 0;
1010                         }
1011                 } else {
1012                         _play_sound_all_type(curr_sound_type, 0.0);
1013                 }
1014
1015                 /*edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL); */
1016                 /*elm_spinner_min_max_get(obj, &min, &max); */
1017                 /*DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx); */
1018                 double posx = 0.0;
1019                 posx = (double)(w / max) * idx;
1020                 /*edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0); */
1021         }
1022 }
1023 #endif
1024
1025 void _show_multimedia_popup(void *data, Evas_Object *obj, void *event_info)
1026 {
1027         Evas_Object *ly;
1028         appdata *ad = data;
1029
1030         if (ad == NULL)
1031                 return;
1032
1033         is_play_media_sound = 0;
1034
1035         original_sound_mode = get_sound_mode();
1036
1037         curr_sound_type = SOUND_TYPE_MEDIA;
1038
1039         vconf_get_int(VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT, &volume_index);
1040
1041         int real_volume_index = 0;
1042         sound_manager_get_volume(SOUND_TYPE_MEDIA, &real_volume_index);
1043
1044         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1045
1046         /* sync volume */
1047         volume_index = sync_volume(volume_index, real_volume_index);
1048         original_volume = volume_index;
1049
1050         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1051
1052
1053         ly = elm_layout_add(ad->nf);
1054 #ifdef O_TYPE
1055         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1056 #else
1057         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1058 #endif
1059         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1060         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1061
1062         int w, h;
1063         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1064         DBG("    ----> width : %d,  height : %d ", w, h);
1065
1066 #ifdef O_TYPE
1067         Evas_Object *label = elm_label_add(ly);
1068         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1069         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1070
1071         char *tempbuf[128];
1072         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1073         elm_object_text_set(label, tempbuf);
1074         elm_object_part_content_set(ly, "elm.icon.2", label);
1075         evas_object_show(label);
1076
1077         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1078
1079         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1080         eext_circle_object_value_set(slider, volume_index);
1081
1082         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1083         eext_circle_object_slider_step_set(slider, 1);
1084         evas_object_smart_callback_add(slider, "value,changed", multimedia_value_changed, label);
1085 #else
1086         Evas_Object *spinner = elm_spinner_add(ly);
1087
1088         g_volume_spinner = spinner;
1089
1090         elm_spinner_editable_set(spinner, EINA_FALSE);
1091         elm_spinner_min_max_set(spinner, 0, 15);
1092         elm_spinner_value_set(spinner, volume_index);
1093         _update_volume_circle(spinner);
1094         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1095         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1096 #endif
1097         Evas_Object *btn_cancel;
1098         btn_cancel = elm_button_add(ly);
1099         elm_object_style_set(btn_cancel, "default");
1100         evas_object_size_hint_weight_set(btn_cancel, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1101         elm_object_translatable_text_set(btn_cancel, "IDS_ST_BUTTON_CANCEL_ABB2");
1102         elm_object_part_content_set(ly, "btn1", btn_cancel);
1103         evas_object_smart_callback_add(btn_cancel, "clicked", _set_cancel_cb, ad);
1104
1105         Evas_Object *btn_ok;
1106         btn_ok = elm_button_add(ly);
1107         elm_object_style_set(btn_ok, "default");
1108         evas_object_size_hint_weight_set(btn_ok, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1109         elm_object_translatable_text_set(btn_ok, "IDS_WNOTI_BUTTON_OK_ABB2");
1110         elm_object_part_content_set(ly, "btn2", btn_ok);
1111         evas_object_smart_callback_add(btn_ok, "clicked", _set_multimedia_clicked_cb, ad);
1112
1113         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1114                                                                                                          "IDS_ST_BUTTON_MULTIMEDIA",
1115                                                                                                          NULL, NULL,
1116                                                                                                          ly, NULL);
1117         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1118         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1119
1120         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1121         /*register_vconf_changing(VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT ,_media_vconf_changing_cb, NULL); */
1122
1123         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1124
1125         /* Unregister sound mode vconf callback */
1126         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1127         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1128 }
1129
1130 static void _set_ringtone_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1131 {
1132         appdata *ad = data;
1133         if (ad == NULL)
1134                 return;
1135
1136         if (!is_changed) {
1137                 DBG("not changed");
1138                 elm_naviframe_item_pop(ad->nf);
1139                 return;
1140         }
1141
1142         /* save ringtone vulume value */
1143         _set_volumn(SOUND_TYPE_RINGTONE, volume_index, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
1144
1145         if (is_created_player()) {
1146                 _close_player(ad, curr_sound_type);
1147         }
1148
1149         stop_wav();
1150
1151         elm_naviframe_item_pop(ad->nf);
1152 }
1153
1154 void _show_ringtone_popup(void *data, Evas_Object *obj, void *event_info)
1155 {
1156         Evas_Object *ly;
1157         Evas_Object *btn;
1158         appdata *ad = data;
1159         int sound_mode;
1160
1161         if (ad == NULL)
1162                 return;
1163
1164         original_sound_mode = get_sound_mode();
1165
1166         curr_sound_type = SOUND_TYPE_RINGTONE;
1167
1168         vconf_get_int(VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT, &volume_index);
1169
1170         DBG("Setting - Ringtone volume is %d", volume_index);
1171
1172         sound_mode = get_sound_mode();
1173
1174         int real_volume_index = 0;
1175         sound_manager_get_volume(SOUND_TYPE_RINGTONE, &real_volume_index);
1176
1177         int virtual_index = real_volume_index;
1178
1179         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, virtual_index);
1180
1181         if (sound_mode != SOUND_MODE_SOUND) {
1182                 DBG("sound_mode != SOUND_MODE_SOUND ---> set to zero -> mode:%d ", sound_mode);
1183                 virtual_index = 0;
1184         }
1185
1186         /* sync volume */
1187         volume_index = sync_volume(volume_index, virtual_index);
1188         original_volume = real_volume_index;
1189
1190         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1191
1192         ly = elm_layout_add(ad->nf);
1193 #ifdef O_TYPE
1194         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1195 #else
1196         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1197 #endif
1198         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1199         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1200
1201         int w, h;
1202         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1203         DBG("    ----> width : %d,  height : %d ", w, h);
1204         if (w == 360 && h == 480) {
1205                 DBG("make long height !!!!!!!!!!!!!!!!!");
1206                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1207                 elm_object_signal_emit(ly, "set,popup,long", "*");
1208         }
1209
1210 #ifdef O_TYPE
1211         Evas_Object *label = elm_label_add(ly);
1212         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1213         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1214
1215         char *tempbuf[128];
1216         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1217         elm_object_text_set(label, tempbuf);
1218         evas_object_resize(label, 200, 200);
1219         elm_object_part_content_set(ly, "elm.icon.2", label);
1220         if (get_sound_mode() != SOUND_MODE_SOUND)
1221                 evas_object_color_set(label, 83, 94, 102, 255);
1222         evas_object_show(label);
1223
1224         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1225
1226         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1227         eext_circle_object_value_set(slider, volume_index);
1228
1229         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1230         eext_circle_object_slider_step_set(slider, 1);
1231         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1232 #else
1233
1234         Evas_Object *spinner = elm_spinner_add(ly);
1235
1236         g_volume_spinner = spinner;
1237
1238         DBG("Setting- Volume: %d", volume_index);
1239
1240         elm_spinner_editable_set(spinner, EINA_FALSE);
1241         elm_spinner_min_max_set(spinner, 0, 15);
1242
1243         if (sound_mode != SOUND_MODE_SOUND) {
1244                 elm_spinner_value_set(spinner, volume_index);
1245                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1246                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1247
1248                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1249                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1250                 }
1251
1252                 elm_object_disabled_set(spinner, EINA_TRUE);
1253         } else {
1254                 elm_spinner_value_set(spinner, volume_index);
1255                 _update_volume_circle(spinner);
1256         }
1257         evas_object_smart_callback_add(spinner, "changed", _on_volume_spinner_change_cb, ly);
1258         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1259 #endif
1260         btn = elm_button_add(ly);
1261         elm_object_style_set(btn, "default");
1262         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1263         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1264         elm_object_part_content_set(ly, "btn1", btn);
1265         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1266
1267         btn = elm_button_add(ly);
1268         elm_object_style_set(btn, "default");
1269         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1270         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1271         elm_object_part_content_set(ly, "btn2", btn);
1272         evas_object_smart_callback_add(btn, "clicked", _set_ringtone_clicked_cb, ad);
1273
1274         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1275                                                                                                          "IDS_ST_HEADER_RINGTONES_ABB",
1276                                                                                                          NULL, NULL,
1277                                                                                                          ly, NULL);
1278
1279         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1280         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1281
1282         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1283
1284         sound_manager_set_volume_changed_cb(_rigngtone_volume_changed_cb, NULL);
1285
1286         /* Unregister sound mode vconf callback */
1287         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1288         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1289 }
1290
1291 static void _set_notification_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1292 {
1293         appdata *ad = data;
1294         if (ad == NULL)
1295                 return;
1296
1297         if (!is_changed) {
1298                 DBG("not changed");
1299                 elm_naviframe_item_pop(ad->nf);
1300                 return;
1301         }
1302
1303         _set_volumn(SOUND_TYPE_NOTIFICATION, volume_index, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
1304
1305         if (is_created_player()) {
1306                 _close_player(ad, curr_sound_type);
1307         }
1308
1309         stop_wav();
1310
1311         elm_naviframe_item_pop(ad->nf);
1312 }
1313
1314 void _show_notification_popup(void *data, Evas_Object *obj, void *event_info)
1315 {
1316         Evas_Object *ly;
1317         Evas_Object *btn;
1318         appdata *ad = data;
1319         int sound_mode;
1320
1321         if (ad == NULL)
1322                 return;
1323
1324         original_sound_mode = get_sound_mode();
1325
1326         curr_sound_type = SOUND_TYPE_NOTIFICATION;
1327
1328         vconf_get_int(VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT, &volume_index);
1329
1330         DBG("Setting - Notification volume is %d", volume_index);
1331         sound_mode = get_sound_mode();
1332
1333         int real_volume_index = 0;
1334         sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &real_volume_index);
1335
1336         int virtual_index = real_volume_index;
1337
1338         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1339         DBG("current sound mode is : %d <--------", sound_mode);
1340
1341         if (sound_mode != SOUND_MODE_SOUND)
1342                 virtual_index = 0;
1343         else {
1344                 DBG("Sound Mode is - %d ", sound_mode);
1345         }
1346
1347         /* sync volume */
1348         volume_index = sync_volume(volume_index, virtual_index);
1349         original_volume = real_volume_index;
1350
1351         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1352
1353         ly = elm_layout_add(ad->nf);
1354 #ifdef O_TYPE
1355         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1356 #else
1357         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1358 #endif
1359         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1360         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1361
1362         int w, h;
1363         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1364         DBG("    ----> width : %d,  height : %d ", w, h);
1365         if (w == 360 && h == 480) {
1366                 DBG("make long height !!!!!!!!!!!!!!!!!");
1367                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1368                 elm_object_signal_emit(ly, "set,popup,long", "*");
1369         }
1370 #ifdef O_TYPE
1371         Evas_Object *label = elm_label_add(ly);
1372         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1373         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1374
1375         char *tempbuf[128];
1376         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1377         elm_object_text_set(label, tempbuf);
1378         evas_object_resize(label, 200, 200);
1379         elm_object_part_content_set(ly, "elm.icon.2", label);
1380         if (get_sound_mode() != SOUND_MODE_SOUND)
1381                 evas_object_color_set(label, 83, 94, 102, 255);
1382         evas_object_show(label);
1383
1384         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1385
1386         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1387         eext_circle_object_value_set(slider, volume_index);
1388
1389         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1390         eext_circle_object_slider_step_set(slider, 1);
1391         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1392 #else
1393
1394         Evas_Object *spinner = elm_spinner_add(ly);
1395
1396         g_volume_spinner = spinner;
1397
1398         DBG("Setting- Volume: %d", volume_index);
1399
1400         /*elm_object_style_set(spinner, "volumestyle"); */
1401         elm_spinner_editable_set(spinner, EINA_FALSE);
1402         elm_spinner_min_max_set(spinner, 0, 15);
1403
1404         if (get_sound_mode() != SOUND_MODE_SOUND) {
1405                 elm_spinner_value_set(spinner, volume_index);
1406                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1407                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1408
1409                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1410                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1411                 }
1412
1413                 elm_object_disabled_set(spinner, EINA_TRUE);
1414         } else {
1415                 elm_spinner_value_set(spinner, volume_index);
1416                 _update_volume_circle(spinner);
1417         }
1418         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1419         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1420 #endif
1421         btn = elm_button_add(ly);
1422         elm_object_style_set(btn, "default");
1423         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1424         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1425         elm_object_part_content_set(ly, "btn1", btn);
1426         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1427
1428         btn = elm_button_add(ly);
1429         elm_object_style_set(btn, "default");
1430         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1431         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1432         elm_object_part_content_set(ly, "btn2", btn);
1433         evas_object_smart_callback_add(btn, "clicked", _set_notification_clicked_cb, ad);
1434
1435         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1436                                                                                                          "IDS_ST_BUTTON_NOTIFICATIONS",
1437                                                                                                          NULL, NULL,
1438                                                                                                          ly, NULL);
1439         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1440         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1441         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1442
1443         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1444
1445         /* Unregister sound mode vconf callback */
1446         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1447         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1448 }
1449
1450 static void _set_system_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1451 {
1452         appdata *ad = data;
1453         if (ad == NULL)
1454                 return;
1455
1456         if (!is_changed) {
1457                 DBG("not changed");
1458                 elm_naviframe_item_pop(ad->nf);
1459                 return;
1460         }
1461
1462         /* save system vulume value */
1463         _set_volumn(SOUND_TYPE_SYSTEM, volume_index, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
1464
1465         if (is_created_player()) {
1466                 _close_player(ad, curr_sound_type);
1467         }
1468
1469         stop_wav();
1470
1471         elm_naviframe_item_pop(ad->nf);
1472 }
1473
1474
1475 void _show_system_popup(void *data, Evas_Object *obj, void *event_info)
1476 {
1477         Evas_Object *ly;
1478         Evas_Object *btn;
1479         appdata *ad = data;
1480         int sound_mode;
1481
1482         if (ad == NULL)
1483                 return;
1484
1485         original_sound_mode = get_sound_mode();
1486
1487         curr_sound_type = SOUND_TYPE_SYSTEM;
1488
1489         vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT, &volume_index);
1490
1491         DBG("Setting - Notification volume is %d", volume_index);
1492         sound_mode = get_sound_mode();
1493
1494         int real_volume_index = 0;
1495         sound_manager_get_volume(SOUND_TYPE_SYSTEM, &real_volume_index);
1496
1497         int virtual_index = real_volume_index;
1498
1499         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1500         if (sound_mode != SOUND_MODE_SOUND)
1501                 virtual_index = 0;
1502         else {
1503                 DBG("Sound Mode is - %d ", sound_mode);
1504         }
1505
1506         /* sync volume */
1507         volume_index = sync_volume(volume_index, virtual_index);
1508         original_volume = real_volume_index;
1509
1510         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1511
1512         ly = elm_layout_add(ad->nf);
1513 #ifdef O_TYPE
1514         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1515 #else
1516         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1517 #endif
1518         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1519         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1520
1521         int w, h;
1522         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1523         DBG("    ----> width : %d,  height : %d ", w, h);
1524         if (w == 360 && h == 480) {
1525                 DBG("make long height !!!!!!!!!!!!!!!!!");
1526                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1527                 elm_object_signal_emit(ly, "set,popup,long", "*");
1528         }
1529 #ifdef O_TYPE
1530         Evas_Object *label = elm_label_add(ly);
1531         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1532         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1533
1534         char *tempbuf[128];
1535         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1536         elm_object_text_set(label, tempbuf);
1537         evas_object_resize(label, 200, 200);
1538         elm_object_part_content_set(ly, "elm.icon.2", label);
1539         if (get_sound_mode() != SOUND_MODE_SOUND)
1540                 evas_object_color_set(label, 83, 94, 102, 255);
1541
1542         evas_object_show(label);
1543
1544         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1545
1546         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1547         eext_circle_object_value_set(slider, volume_index);
1548
1549         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1550         eext_circle_object_slider_step_set(slider, 1);
1551         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1552 #else
1553
1554
1555         Evas_Object *spinner = elm_spinner_add(ly);
1556
1557         g_volume_spinner = spinner;
1558
1559         DBG("Setting- Volume: %d", volume_index);
1560
1561         /*elm_object_style_set(spinner, "volumestyle"); */
1562         elm_spinner_editable_set(spinner, EINA_FALSE);
1563         elm_spinner_min_max_set(spinner, 0, 15);
1564
1565         if (get_sound_mode() != SOUND_MODE_SOUND) {
1566                 elm_spinner_value_set(spinner, volume_index);
1567                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1568                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1569
1570                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1571                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1572                 }
1573
1574                 elm_object_disabled_set(spinner, EINA_TRUE);
1575         } else {
1576                 elm_spinner_value_set(spinner, volume_index);
1577                 _update_volume_circle(spinner);
1578         }
1579         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1580         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1581 #endif
1582         btn = elm_button_add(ly);
1583         elm_object_style_set(btn, "default");
1584         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1585         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1586         elm_object_part_content_set(ly, "btn1", btn);
1587         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1588
1589         btn = elm_button_add(ly);
1590         elm_object_style_set(btn, "default");
1591         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1592         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1593         elm_object_part_content_set(ly, "btn2", btn);
1594         evas_object_smart_callback_add(btn, "clicked", _set_system_clicked_cb, ad);
1595
1596         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1597                                                                                                          "IDS_ST_BODY_SYSTEM_M_VOLUME_ABB",
1598                                                                                                          NULL, NULL,
1599                                                                                                          ly, NULL);
1600         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1601         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1602
1603         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1604
1605         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1606
1607         /* Unregister sound mode vconf callback */
1608         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1609         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1610 }