src/setting-volume.c

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