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 Evas_Object *_create_volume_list(void *data)
 355 {
 356         appdata *ad = data;
 357         if (ad == NULL) {
 358                 DBG("%s", "_create_volume_list - appdata is null");
 359                 return NULL;
 360         }
 361         Evas_Object *genlist  = NULL;
 362         Elm_Object_Item *item = NULL;
 363         struct _volume_menu_item *menu_its = NULL;
 364         int idx = 0;
 365
 366         g_ad = ad;
 367
 368         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 369         itc->item_style = "1text";
 370         itc->func.text_get = _gl_volume_title_get;
 371         itc->func.del = _volumn_gl_del;
 372
 373         genlist = elm_genlist_add(ad->nf);
 374         elm_genlist_block_count_set(genlist, 14);
 375         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 376 #ifdef O_TYPE
 377         Evas_Object *circle_genlist = eext_circle_object_genlist_add(genlist, ad->circle_surface);
 378         eext_circle_object_genlist_scroller_policy_set(circle_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 379         eext_rotary_object_event_activated_set(circle_genlist, EINA_TRUE);
 380 #endif
 381
 382         menu_its = volume_menu_its;
 383
 384         for (idx = 0; idx < VOLUMN_ITEM_COUNT; idx++) {
 385                 Item_Data *id = calloc(sizeof(Item_Data), 1);
 386                 if (id) {
 387                         id->index = idx;
 388                         item = elm_genlist_item_append(
 389                                            genlist,                     /* genlist object */
 390                                            itc,                         /* item class */
 391                                            id,                      /* data */
 392                                            NULL,
 393                                            ELM_GENLIST_ITEM_NONE,
 394                                            menu_its[idx].func,  /* call back */
 395                                            ad);
 396                         id->item = item;
 397                 }
 398         }
 399         elm_genlist_item_class_free(itc);
 400
 401         return genlist;
 402 }
 403
 404 static void change_sound_mode(int mode)
 405 {
 406         switch (mode) {
 407         case SOUND_MODE_SOUND:
 408                 DBG("Setting - Change sound mode to Sound!");
 409
 410                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 411                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 412                 break;
 413         case SOUND_MODE_VIBRATE:
 414                 DBG("Setting - Change sound mode to Sound!");
 415
 416                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 417                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 418                 break;
 419         case SOUND_MODE_MUTE:
 420                 DBG("Setting - Change sound mode to Sound!");
 421
 422                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 423                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 424                 break;
 425         }
 426 }
 427
 428 static void _set_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 429 {
 430         appdata *ad = data;
 431         if (ad == NULL)
 432                 return;
 433
 434         if (!is_changed) {
 435                 DBG("not changed");
 436                 elm_naviframe_item_pop(ad->nf);
 437                 return;
 438         }
 439 #if 1
 440         DBG("Setting - original volume : %d", original_volume);
 441
 442         char vconf_key[512] = {0,};
 443
 444         switch (curr_sound_type) {
 445         case SOUND_TYPE_MEDIA:
 446                 strcpy(vconf_key, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 447                 break;
 448         case SOUND_TYPE_RINGTONE:
 449                 strcpy(vconf_key, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
 450                 break;
 451         case SOUND_TYPE_SYSTEM:
 452                 strcpy(vconf_key, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
 453                 break;
 454         case SOUND_TYPE_NOTIFICATION:
 455                 strcpy(vconf_key, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
 456                 break;
 457         }
 458
 459         /* restore original vulume value */
 460         _set_volumn(curr_sound_type, original_volume, vconf_key);
 461 #endif
 462
 463         if (original_sound_mode != get_sound_mode()) {
 464                 /* restore sound mode */
 465                 change_sound_mode(original_sound_mode);
 466         }
 467
 468         /*original_volume = 0; */
 469
 470         if (is_created_player()) {
 471                 _close_player(ad, curr_sound_type);
 472         }
 473
 474         stop_wav();
 475
 476         elm_naviframe_item_pop(ad->nf);
 477 }
 478
 479 static Eina_Bool _back_volume_naviframe_cb(void *data, Elm_Object_Item *it)
 480 {
 481         DBG("Setting - _back_volume_naviframe_cb is called");
 482         DBG("Setting - original volume : %d", original_volume);
 483         DBG("Setting -    volume index : %d", volume_index);
 484
 485 #if 0
 486         char vconf_key[512] = {0,};
 487         switch (curr_sound_type) {
 488         case SOUND_TYPE_MEDIA:
 489                 strcpy(vconf_key, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 490                 break;
 491         case SOUND_TYPE_RINGTONE:
 492                 strcpy(vconf_key, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
 493                 break;
 494         case SOUND_TYPE_SYSTEM:
 495                 strcpy(vconf_key, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
 496                 break;
 497         case SOUND_TYPE_NOTIFICATION:
 498                 strcpy(vconf_key, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
 499                 break;
 500         }
 501
 502         _set_volumn(curr_sound_type,   volume_index, vconf_key);
 503 #endif
 504         if (original_sound_mode != get_sound_mode()) {
 505                 /* restore sound mode */
 506                 change_sound_mode(original_sound_mode);
 507         }
 508
 509         if (is_created_player()) {
 510                 _close_player(data, curr_sound_type);
 511         }
 512
 513         g_volume_spinner = NULL;
 514
 515         is_changed = 0;         /* initialize flag! */
 516
 517         stop_wav();
 518
 519         unregister_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume);
 520
 521         sound_manager_unset_volume_changed_cb();
 522
 523         /* Unregister sound mode vconf callback */
 524         unregister_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb);
 525         unregister_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb);
 526
 527         return EINA_TRUE;
 528 }
 529
 530 static void _set_volumn(sound_type_e type, int volume_index, char *vconf_key)
 531 {
 532         DBG("Setting - set_volume() is called!");
 533
 534         int err = -1;
 535         err = sound_manager_set_volume(type, volume_index);
 536
 537         /* save system vulume value */
 538         if (err == SOUND_MANAGER_ERROR_NONE) {
 539                 int vret = vconf_set_int(vconf_key, volume_index);
 540                 DBG(" ret = %d , %s :: %d ", vret, vconf_key, volume_index);
 541
 542                 if (curr_sound_type == SOUND_TYPE_RINGTONE) {
 543                         DBG("Ringtone volume is changed....!");
 544
 545                         if (volume_index == 0 && get_sound_mode() == SOUND_MODE_SOUND) {
 546                                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 547                                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 548                         } else if (volume_index > 0 && get_sound_mode() != SOUND_MODE_SOUND) {
 549                                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 550                                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 551                         }
 552                 } else {
 553                         DBG("current sound mode is %d, not type_ringtone", curr_sound_type);
 554                 }
 555         } else {
 556                 DBG("Setting - ringtone value is not saved...   %d", volume_index);
 557         }
 558 }
 559
 560 static void _set_multimedia_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 561 {
 562         appdata *ad = data;
 563         if (ad == NULL)
 564                 return;
 565
 566         if (!is_changed) {
 567                 DBG("not changed");
 568                 elm_naviframe_item_pop(ad->nf);
 569                 return;
 570         }
 571
 572         /* save multimedia vulume value */
 573         _set_volumn(SOUND_TYPE_MEDIA, volume_index, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 574
 575
 576         if (is_created_player()) {
 577                 _close_player(ad, curr_sound_type);
 578         }
 579
 580         stop_wav();
 581
 582         elm_naviframe_item_pop(ad->nf);
 583 }
 584
 585 static void _play_sound_all_type(int sound_type, float volume)
 586 {
 587         if (is_myself_ringtone_changing) {
 588                 DBG(" is_myself_ringtone_changing !!!!!!!!!!!");
 589
 590                 return;
 591         }
 592
 593         char buf[1024];
 594         const char *sound_path = NULL;
 595         int temp_volume_index = 0;
 596         switch (sound_type) {
 597         case SOUND_TYPE_RINGTONE:
 598                 temp_volume_index = volume_index;
 599
 600                 vconf_set_int(VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT, temp_volume_index);
 601                 vconf_set_int("db/setting/sound/call/rmd_ringtone_volume", temp_volume_index);  /* backup ringtone volume */
 602
 603                 sound_path = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 604                 if (sound_path) {
 605                         sprintf(buf, "%s", sound_path);
 606                 } else {
 607                         sprintf(buf, "%s", VCONFKEY_SETAPPL_CALL_RINGTONE_DEFAULT_PATH_STR);
 608                 }
 609
 610                 break;
 611         case SOUND_TYPE_MEDIA:
 612                 _set_volumn(sound_type, volume_index, VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT);
 613
 614                 sprintf(buf, "%s", SETTING_DEFAULT_MEDIA_TONE);
 615                 break;
 616         case SOUND_TYPE_NOTIFICATION:
 617                 vconf_set_int(VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT, volume_index);
 618                 temp_volume_index = volume_index;
 619
 620                 sound_path = vconf_get_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR);
 621                 if (sound_path) {
 622                         sprintf(buf, "%s", sound_path);
 623                 } else {
 624                         sprintf(buf, "%s", SETTING_DEFAULT_MSG_TONE);
 625                 }
 626                 break;
 627         case SOUND_TYPE_SYSTEM:
 628                 vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT, volume_index);
 629
 630                 sprintf(buf, "%s", SETTING_DEFAULT_SYS_TONE);
 631                 break;
 632         }
 633
 634         int err = -1;
 635
 636         if (sound_type == SOUND_TYPE_RINGTONE) {
 637                 DBG("Setting - ringtone safety volume!!");
 638                 DBG("Setting - real volume : %d", temp_volume_index);
 639
 640                 sound_manager_set_volume(sound_type, temp_volume_index);
 641         } else if (sound_type == SOUND_TYPE_NOTIFICATION) {
 642                 DBG("Setting - notification safety volume!!");
 643                 sound_manager_set_volume(sound_type, temp_volume_index);
 644         } else {
 645                 DBG("Setting - normal volume!! ----- volume_index : %d ", volume_index);
 646                 err = sound_manager_set_volume(sound_type, volume_index);
 647                 if (err != SOUND_MANAGER_ERROR_NONE) {
 648                         ERR("Setting - sound_manager_set_volume() is failed! : %d", err);
 649                 }
 650         }
 651
 652         if (sound_type == SOUND_TYPE_RINGTONE) {
 653                 if (!is_created_player() || is_player_paused()) {
 654                         play_sound(buf, volume, SOUND_TYPE_RINGTONE);
 655                         set_looping(TRUE);
 656                 }
 657                 is_myself_ringtone_changing = 1;
 658         } else if (sound_type == SOUND_TYPE_MEDIA) {
 659                 int music_state = 0;
 660                 int err = vconf_get_int("memory/private/org.tizen.w-music-player/player_state", &music_state);
 661
 662                 DBG("Setting - music state: %d, err: %d", music_state, err);
 663
 664                 if (music_state == VCONFKEY_MUSIC_PLAY) {
 665                         DBG("Setting - media is playing...");
 666                         return;
 667                 }
 668
 669                 if (!is_created_player() || is_player_paused()) {
 670                         play_sound(buf, volume, SOUND_TYPE_MEDIA);
 671                         set_looping(TRUE);
 672                 }
 673         }
 674
 675         else if (sound_type == SOUND_TYPE_SYSTEM) {
 676                 stop_wav();
 677
 678                 is_wav_playing_vol = SOUND_STATE_PLAY;
 679                 wav_player_start(buf, sound_type, NULL, NULL, &sound_id_vol);
 680                 return;
 681         } else if (sound_type == SOUND_TYPE_NOTIFICATION) {
 682                 play_sound(buf, 0.0, SOUND_TYPE_NOTIFICATION);
 683                 set_looping(FALSE);
 684
 685                 return;
 686         }
 687 }
 688
 689 static void _change_to_vibrate_mode()
 690 {
 691         DBG("Setting - _change_to_vibrate_mode() is called!");
 692
 693         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 694                 return;
 695         }
 696
 697         if (get_sound_mode() != SOUND_MODE_VIBRATE) {
 698                 DBG("Setting - Change sound mode to vibrate!");
 699
 700                 is_myself_changing = 1;
 701
 702                 _stop_all_volume_sound();
 703
 704                 _start_vibration(3, SETTING_VIB_STRONG_RATE, SETTING_DEFAULT_SYSTEM_HAPTIC_PREVIEW_VIB);
 705
 706                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 707                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 708         }
 709 }
 710
 711 static void _change_to_sound_mode()
 712 {
 713         DBG("Setting - _change_to_sound_mode() is called!");
 714
 715         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 716                 return;
 717         }
 718
 719         if (get_sound_mode() != SOUND_MODE_SOUND) {
 720                 DBG("Setting - Change sound mode to sound!");
 721
 722                 is_myself_changing = 1;
 723
 724                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 725                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 726         }
 727 }
 728
 729 static int sync_volume(int vconf_vol, int real_vol)
 730 {
 731         if (vconf_vol != real_vol)
 732                 return real_vol;
 733         return vconf_vol;
 734 }
 735
 736 static void _update_volume_circle(Evas_Object *spiner)
 737 {
 738         if (spiner == NULL)
 739                 return;
 740
 741         Evas_Coord w;
 742         double min, max, posx;
 743         int idx = (int) elm_spinner_value_get(spiner);
 744
 745         edje_object_part_geometry_get(elm_layout_edje_get(spiner), "center.image2", NULL, NULL, &w, NULL);
 746         elm_spinner_min_max_get(spiner, &min, &max);
 747
 748         if (idx == max)
 749                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,full", "elm");
 750         if (idx < max)
 751                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,default", "elm");
 752         if (idx == min) {
 753                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,min", "elm");
 754                 if (curr_sound_type != SOUND_TYPE_MEDIA && get_sound_mode() == SOUND_MODE_VIBRATE) {
 755                         edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,vibrate", "elm");
 756                 }
 757         }
 758         if (idx > min)
 759                 edje_object_signal_emit(elm_layout_edje_get(spiner), "elm,spinner,normal", "elm");
 760
 761         posx = (double)(w / max) * idx;
 762
 763         edje_object_part_drag_value_set(elm_layout_edje_get(spiner), "elm.dragable.slider", posx, 0);
 764 }
 765
 766 static void _on_volume_spinner_change_cb(void *data, Evas_Object *obj, void *event_info)
 767 {
 768         DBG("Setting - _on_volume_spinner_change_cb() is called!");
 769
 770         if (is_changing_level_by_vconf) {
 771                 DBG("Setting - is_changing_level_by_vconf!!!!");
 772
 773                 is_changing_level_by_vconf = 0;
 774                 return;
 775         }
 776
 777         is_changed = 1; /* changed flag!! */
 778
 779         Evas_Coord w;
 780
 781         double min, max;
 782         int idx = (int) elm_spinner_value_get(obj);
 783
 784         volume_index = idx;
 785
 786         DBG("Setting - volume_index : %d", volume_index);
 787
 788         if (get_sound_mode() != SOUND_MODE_MUTE) {
 789                 if (!is_play_ringtone_sound) {
 790                         _play_sound_all_type(curr_sound_type, 0.0);
 791                 } else {
 792                         is_play_ringtone_sound = 0;
 793                 }
 794         }
 795
 796         edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL);
 797         elm_spinner_min_max_get(obj, &min, &max);
 798
 799         DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx);
 800
 801         if (idx == max) {
 802                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,full", "elm");
 803         }
 804         if (idx < max) {
 805                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,default", "elm");
 806         }
 807         if (idx == min) {
 808                 if (get_sound_mode() != SOUND_MODE_VIBRATE) {
 809                         _change_to_vibrate_mode();
 810                 }
 811                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 812                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,vibrate", "elm");
 813         }
 814         if (idx > min) {
 815                 if (get_sound_mode() == SOUND_MODE_MUTE) {
 816                         _change_to_vibrate_mode();
 817                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 818                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,vibrate", "elm");
 819
 820                         elm_spinner_value_set(obj, 0);
 821                 } else {
 822                         _change_to_sound_mode();
 823                         edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,normal", "elm");
 824                 }
 825         }
 826
 827         double posx = 0.0;
 828         if (get_sound_mode() == SOUND_MODE_MUTE) {
 829                 posx = 0;
 830         } else {
 831                 posx = (double)(w / max) * idx;
 832         }
 833
 834         edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0);
 835 }
 836
 837 static void _on_media_volume_spinner_change_cb(void *data, Evas_Object *obj, void *event_info)
 838 {
 839         DBG("Setting - _on_media_volume_spinner_change_cb() is called!");
 840
 841         if (curr_sound_type != SOUND_TYPE_MEDIA) {
 842                 if (is_changing_level_by_vconf) {
 843                         DBG("Setting - is_changing_level_by_vconf!!!!");
 844
 845                         is_changing_level_by_vconf = 0;
 846                         return;
 847                 }
 848         }
 849
 850         Evas_Coord w;
 851
 852         double min, max;
 853         int idx = (int) elm_spinner_value_get(obj);
 854
 855         is_changed = 1;         /* changed flag!! */
 856
 857         volume_index = idx;
 858
 859         DBG("Setting - volume_index : %d", volume_index);
 860
 861         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 862                 if (!is_play_media_sound) {
 863                         _play_sound_all_type(curr_sound_type, 0.0);
 864                         is_play_media_sound = 0;
 865                 } else {
 866                         is_play_media_sound = 0;
 867                 }
 868         } else {
 869                 _play_sound_all_type(curr_sound_type, 0.0);
 870         }
 871
 872         edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL);
 873         elm_spinner_min_max_get(obj, &min, &max);
 874
 875         DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx);
 876
 877         if (idx == max) {
 878                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,full", "elm");
 879         }
 880         if (idx < max) {
 881                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,default", "elm");
 882         }
 883         if (idx == min) {
 884                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,min", "elm");
 885         }
 886         if (idx > min) {
 887                 edje_object_signal_emit(elm_layout_edje_get(obj), "elm,spinner,normal", "elm");
 888         }
 889
 890         double posx = 0.0;
 891         posx = (double)(w / max) * idx;
 892
 893         edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0);
 894 }
 895
 896 #ifdef O_TYPE
 897 static void
 898 multimedia_value_changed(void *data, Evas_Object *obj, void *event_info)
 899 {
 900         DBG("Setting - multimedia_value_changed() is called!");
 901         char buf[PATH_MAX];
 902         Evas_Object *label = data;
 903
 904         snprintf(buf, sizeof(buf), "%.0lf", eext_circle_object_value_get(obj));
 905         DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>> Slider value = %s", buf);
 906         elm_object_text_set(label, buf);
 907
 908         if (curr_sound_type != SOUND_TYPE_MEDIA) {
 909                 if (is_changing_level_by_vconf) {
 910                         DBG("Setting - is_changing_level_by_vconf!!!!");
 911
 912                         is_changing_level_by_vconf = 0;
 913                         return;
 914                 }
 915         }
 916
 917         Evas_Coord w;
 918
 919         double min, max;
 920         int idx = (int) eext_circle_object_value_get(obj);
 921
 922         is_changed = 1;         /* changed flag!! */
 923
 924         volume_index = idx;
 925
 926         DBG("Setting - volume_index : %d", volume_index);
 927
 928         if (curr_sound_type == SOUND_TYPE_MEDIA) {
 929                 if (!is_play_media_sound) {
 930                         _play_sound_all_type(curr_sound_type, 0.0);
 931                         is_play_media_sound = 0;
 932                 } else {
 933                         is_play_media_sound = 0;
 934                 }
 935         } else {
 936                 _play_sound_all_type(curr_sound_type, 0.0);
 937         }
 938
 939         double posx = 0.0;
 940         posx = (double)(w / max) * idx;
 941 }
 942
 943 static void
 944 ringtone_value_changed(void *data, Evas_Object *obj, void *event_info)
 945 {
 946         DBG("Setting - ringtone_value_changed() is called!");
 947         char buf[PATH_MAX];
 948         Evas_Object *label = data;
 949
 950         snprintf(buf, sizeof(buf), "%.0lf", eext_circle_object_value_get(obj));
 951         DBG(">>>>>>>>>>>>>>>>>>>>>>>>>>> Slider value = %s", buf);
 952         if (get_sound_mode() == SOUND_MODE_SOUND) {
 953                 elm_object_text_set(label, buf);
 954
 955                 if (curr_sound_type != SOUND_TYPE_MEDIA) {
 956                         if (is_changing_level_by_vconf) {
 957                                 DBG("Setting - is_changing_level_by_vconf!!!!");
 958
 959                                 is_changing_level_by_vconf = 0;
 960                                 return;
 961                         }
 962                 }
 963
 964                 Evas_Coord w;
 965
 966                 double min, max;
 967                 int idx = (int) eext_circle_object_value_get(obj);
 968
 969                 is_changed = 1;         /* changed flag!! */
 970
 971                 volume_index = idx;
 972
 973                 DBG("Setting - volume_index : %d", volume_index);
 974
 975                 if (curr_sound_type == SOUND_TYPE_MEDIA) {
 976                         if (!is_play_media_sound) {
 977                                 _play_sound_all_type(curr_sound_type, 0.0);
 978                                 is_play_media_sound = 0;
 979                         } else {
 980                                 is_play_media_sound = 0;
 981                         }
 982                 } else {
 983                         _play_sound_all_type(curr_sound_type, 0.0);
 984                 }
 985
 986                 /*edje_object_part_geometry_get(elm_layout_edje_get(obj), "center.image2", NULL, NULL, &w, NULL); */
 987                 /*elm_spinner_min_max_get(obj, &min, &max); */
 988                 /*DBG("Setting - min: %i, max: %i, idx: %d", (int)min, (int)max, idx); */
 989                 double posx = 0.0;
 990                 posx = (double)(w / max) * idx;
 991                 /*edje_object_part_drag_value_set(elm_layout_edje_get(obj), "elm.dragable.slider", posx, 0); */
 992         }
 993 }
 994 #endif
 995
 996 void _show_multimedia_popup(void *data, Evas_Object *obj, void *event_info)
 997 {
 998         Evas_Object *ly;
 999         appdata *ad = data;
1000
1001         if (ad == NULL)
1002                 return;
1003
1004         is_play_media_sound = 0;
1005
1006         original_sound_mode = get_sound_mode();
1007
1008         curr_sound_type = SOUND_TYPE_MEDIA;
1009
1010         vconf_get_int(VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT, &volume_index);
1011
1012         int real_volume_index = 0;
1013         sound_manager_get_volume(SOUND_TYPE_MEDIA, &real_volume_index);
1014
1015         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1016
1017         /* sync volume */
1018         volume_index = sync_volume(volume_index, real_volume_index);
1019         original_volume = volume_index;
1020
1021         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1022
1023
1024         ly = elm_layout_add(ad->nf);
1025 #ifdef O_TYPE
1026         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1027 #else
1028         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1029 #endif
1030         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1031         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1032
1033         int w, h;
1034         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1035         DBG("    ----> width : %d,  height : %d ", w, h);
1036
1037 #ifdef O_TYPE
1038         Evas_Object *label = elm_label_add(ly);
1039         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1040         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1041
1042         char *tempbuf[128];
1043         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1044         elm_object_text_set(label, tempbuf);
1045         elm_object_part_content_set(ly, "elm.icon.2", label);
1046         evas_object_show(label);
1047
1048         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1049
1050         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1051         eext_circle_object_value_set(slider, volume_index);
1052
1053         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1054         eext_circle_object_slider_step_set(slider, 1);
1055         evas_object_smart_callback_add(slider, "value,changed", multimedia_value_changed, label);
1056 #else
1057         Evas_Object *spinner = elm_spinner_add(ly);
1058
1059         g_volume_spinner = spinner;
1060
1061         elm_spinner_editable_set(spinner, EINA_FALSE);
1062         elm_spinner_min_max_set(spinner, 0, 15);
1063         elm_spinner_value_set(spinner, volume_index);
1064         _update_volume_circle(spinner);
1065         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1066         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1067 #endif
1068         Evas_Object *btn_cancel;
1069         btn_cancel = elm_button_add(ly);
1070         elm_object_style_set(btn_cancel, "default");
1071         evas_object_size_hint_weight_set(btn_cancel, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1072         elm_object_translatable_text_set(btn_cancel, "IDS_ST_BUTTON_CANCEL_ABB2");
1073         elm_object_part_content_set(ly, "btn1", btn_cancel);
1074         evas_object_smart_callback_add(btn_cancel, "clicked", _set_cancel_cb, ad);
1075
1076         Evas_Object *btn_ok;
1077         btn_ok = elm_button_add(ly);
1078         elm_object_style_set(btn_ok, "default");
1079         evas_object_size_hint_weight_set(btn_ok, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1080         elm_object_translatable_text_set(btn_ok, "IDS_WNOTI_BUTTON_OK_ABB2");
1081         elm_object_part_content_set(ly, "btn2", btn_ok);
1082         evas_object_smart_callback_add(btn_ok, "clicked", _set_multimedia_clicked_cb, ad);
1083
1084         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1085                                                                                                          "IDS_ST_BUTTON_MULTIMEDIA",
1086                                                                                                          NULL, NULL,
1087                                                                                                          ly, NULL);
1088         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1089         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1090
1091         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1092         /*register_vconf_changing(VCONFKEY_SETAPPL_MEDIA_SOUND_VOLUME_INT ,_media_vconf_changing_cb, NULL); */
1093
1094         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1095
1096         /* Unregister sound mode vconf callback */
1097         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1098         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1099 }
1100
1101 static void _set_ringtone_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1102 {
1103         appdata *ad = data;
1104         if (ad == NULL)
1105                 return;
1106
1107         if (!is_changed) {
1108                 DBG("not changed");
1109                 elm_naviframe_item_pop(ad->nf);
1110                 return;
1111         }
1112
1113         /* save ringtone vulume value */
1114         _set_volumn(SOUND_TYPE_RINGTONE, volume_index, VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT);
1115
1116         if (is_created_player()) {
1117                 _close_player(ad, curr_sound_type);
1118         }
1119
1120         stop_wav();
1121
1122         elm_naviframe_item_pop(ad->nf);
1123 }
1124
1125 void _show_ringtone_popup(void *data, Evas_Object *obj, void *event_info)
1126 {
1127         Evas_Object *ly;
1128         Evas_Object *btn;
1129         appdata *ad = data;
1130         int sound_mode;
1131
1132         if (ad == NULL)
1133                 return;
1134
1135         original_sound_mode = get_sound_mode();
1136
1137         curr_sound_type = SOUND_TYPE_RINGTONE;
1138
1139         vconf_get_int(VCONFKEY_SETAPPL_CALL_RINGTONE_SOUND_VOLUME_INT, &volume_index);
1140
1141         DBG("Setting - Ringtone volume is %d", volume_index);
1142
1143         sound_mode = get_sound_mode();
1144
1145         int real_volume_index = 0;
1146         sound_manager_get_volume(SOUND_TYPE_RINGTONE, &real_volume_index);
1147
1148         int virtual_index = real_volume_index;
1149
1150         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, virtual_index);
1151
1152         if (sound_mode != SOUND_MODE_SOUND) {
1153                 DBG("sound_mode != SOUND_MODE_SOUND ---> set to zero -> mode:%d ", sound_mode);
1154                 virtual_index = 0;
1155         }
1156
1157         /* sync volume */
1158         volume_index = sync_volume(volume_index, virtual_index);
1159         original_volume = real_volume_index;
1160
1161         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1162
1163         ly = elm_layout_add(ad->nf);
1164 #ifdef O_TYPE
1165         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1166 #else
1167         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1168 #endif
1169         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1170         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1171
1172         int w, h;
1173         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1174         DBG("    ----> width : %d,  height : %d ", w, h);
1175         if (w == 360 && h == 480) {
1176                 DBG("make long height !!!!!!!!!!!!!!!!!");
1177                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1178                 elm_object_signal_emit(ly, "set,popup,long", "*");
1179         }
1180
1181 #ifdef O_TYPE
1182         Evas_Object *label = elm_label_add(ly);
1183         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1184         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1185
1186         char *tempbuf[128];
1187         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1188         elm_object_text_set(label, tempbuf);
1189         evas_object_resize(label, 200, 200);
1190         elm_object_part_content_set(ly, "elm.icon.2", label);
1191         if (get_sound_mode() != SOUND_MODE_SOUND)
1192                 evas_object_color_set(label, 83, 94, 102, 255);
1193         evas_object_show(label);
1194
1195         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1196
1197         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1198         eext_circle_object_value_set(slider, volume_index);
1199
1200         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1201         eext_circle_object_slider_step_set(slider, 1);
1202         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1203 #else
1204
1205         Evas_Object *spinner = elm_spinner_add(ly);
1206
1207         g_volume_spinner = spinner;
1208
1209         DBG("Setting- Volume: %d", volume_index);
1210
1211         elm_spinner_editable_set(spinner, EINA_FALSE);
1212         elm_spinner_min_max_set(spinner, 0, 15);
1213
1214         if (sound_mode != SOUND_MODE_SOUND) {
1215                 elm_spinner_value_set(spinner, volume_index);
1216                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1217                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1218
1219                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1220                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1221                 }
1222
1223                 elm_object_disabled_set(spinner, EINA_TRUE);
1224         } else {
1225                 elm_spinner_value_set(spinner, volume_index);
1226                 _update_volume_circle(spinner);
1227         }
1228         evas_object_smart_callback_add(spinner, "changed", _on_volume_spinner_change_cb, ly);
1229         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1230 #endif
1231         btn = elm_button_add(ly);
1232         elm_object_style_set(btn, "default");
1233         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1234         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1235         elm_object_part_content_set(ly, "btn1", btn);
1236         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1237
1238         btn = elm_button_add(ly);
1239         elm_object_style_set(btn, "default");
1240         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1241         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1242         elm_object_part_content_set(ly, "btn2", btn);
1243         evas_object_smart_callback_add(btn, "clicked", _set_ringtone_clicked_cb, ad);
1244
1245         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1246                                                                                                          "IDS_ST_HEADER_RINGTONES_ABB",
1247                                                                                                          NULL, NULL,
1248                                                                                                          ly, NULL);
1249
1250         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1251         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1252
1253         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1254
1255         sound_manager_set_volume_changed_cb(_rigngtone_volume_changed_cb, NULL);
1256
1257         /* Unregister sound mode vconf callback */
1258         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1259         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1260 }
1261
1262 static void _set_notification_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1263 {
1264         appdata *ad = data;
1265         if (ad == NULL)
1266                 return;
1267
1268         if (!is_changed) {
1269                 DBG("not changed");
1270                 elm_naviframe_item_pop(ad->nf);
1271                 return;
1272         }
1273
1274         _set_volumn(SOUND_TYPE_NOTIFICATION, volume_index, VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT);
1275
1276         if (is_created_player()) {
1277                 _close_player(ad, curr_sound_type);
1278         }
1279
1280         stop_wav();
1281
1282         elm_naviframe_item_pop(ad->nf);
1283 }
1284
1285 void _show_notification_popup(void *data, Evas_Object *obj, void *event_info)
1286 {
1287         Evas_Object *ly;
1288         Evas_Object *btn;
1289         appdata *ad = data;
1290         int sound_mode;
1291
1292         if (ad == NULL)
1293                 return;
1294
1295         original_sound_mode = get_sound_mode();
1296
1297         curr_sound_type = SOUND_TYPE_NOTIFICATION;
1298
1299         vconf_get_int(VCONFKEY_SETAPPL_NOTI_SOUND_VOLUME_INT, &volume_index);
1300
1301         DBG("Setting - Notification volume is %d", volume_index);
1302         sound_mode = get_sound_mode();
1303
1304         int real_volume_index = 0;
1305         sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &real_volume_index);
1306
1307         int virtual_index = real_volume_index;
1308
1309         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1310         DBG("current sound mode is : %d <--------", sound_mode);
1311
1312         if (sound_mode != SOUND_MODE_SOUND)
1313                 virtual_index = 0;
1314         else {
1315                 DBG("Sound Mode is - %d ", sound_mode);
1316         }
1317
1318         /* sync volume */
1319         volume_index = sync_volume(volume_index, virtual_index);
1320         original_volume = real_volume_index;
1321
1322         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1323
1324         ly = elm_layout_add(ad->nf);
1325 #ifdef O_TYPE
1326         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1327 #else
1328         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1329 #endif
1330         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1331         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1332
1333         int w, h;
1334         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1335         DBG("    ----> width : %d,  height : %d ", w, h);
1336         if (w == 360 && h == 480) {
1337                 DBG("make long height !!!!!!!!!!!!!!!!!");
1338                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1339                 elm_object_signal_emit(ly, "set,popup,long", "*");
1340         }
1341 #ifdef O_TYPE
1342         Evas_Object *label = elm_label_add(ly);
1343         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1344         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1345
1346         char *tempbuf[128];
1347         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1348         elm_object_text_set(label, tempbuf);
1349         evas_object_resize(label, 200, 200);
1350         elm_object_part_content_set(ly, "elm.icon.2", label);
1351         if (get_sound_mode() != SOUND_MODE_SOUND)
1352                 evas_object_color_set(label, 83, 94, 102, 255);
1353         evas_object_show(label);
1354
1355         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1356
1357         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1358         eext_circle_object_value_set(slider, volume_index);
1359
1360         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1361         eext_circle_object_slider_step_set(slider, 1);
1362         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1363 #else
1364
1365         Evas_Object *spinner = elm_spinner_add(ly);
1366
1367         g_volume_spinner = spinner;
1368
1369         DBG("Setting- Volume: %d", volume_index);
1370
1371         /*elm_object_style_set(spinner, "volumestyle"); */
1372         elm_spinner_editable_set(spinner, EINA_FALSE);
1373         elm_spinner_min_max_set(spinner, 0, 15);
1374
1375         if (get_sound_mode() != SOUND_MODE_SOUND) {
1376                 elm_spinner_value_set(spinner, volume_index);
1377                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1378                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1379
1380                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1381                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1382                 }
1383
1384                 elm_object_disabled_set(spinner, EINA_TRUE);
1385         } else {
1386                 elm_spinner_value_set(spinner, volume_index);
1387                 _update_volume_circle(spinner);
1388         }
1389         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1390         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1391 #endif
1392         btn = elm_button_add(ly);
1393         elm_object_style_set(btn, "default");
1394         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1395         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1396         elm_object_part_content_set(ly, "btn1", btn);
1397         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1398
1399         btn = elm_button_add(ly);
1400         elm_object_style_set(btn, "default");
1401         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1402         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1403         elm_object_part_content_set(ly, "btn2", btn);
1404         evas_object_smart_callback_add(btn, "clicked", _set_notification_clicked_cb, ad);
1405
1406         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1407                                                                                                          "IDS_ST_BUTTON_NOTIFICATIONS",
1408                                                                                                          NULL, NULL,
1409                                                                                                          ly, NULL);
1410         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1411         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1412         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1413
1414         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1415
1416         /* Unregister sound mode vconf callback */
1417         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1418         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1419 }
1420
1421 static void _set_system_clicked_cb(void *data, Evas_Object *obj, void *event_info)
1422 {
1423         appdata *ad = data;
1424         if (ad == NULL)
1425                 return;
1426
1427         if (!is_changed) {
1428                 DBG("not changed");
1429                 elm_naviframe_item_pop(ad->nf);
1430                 return;
1431         }
1432
1433         /* save system vulume value */
1434         _set_volumn(SOUND_TYPE_SYSTEM, volume_index, VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT);
1435
1436         if (is_created_player()) {
1437                 _close_player(ad, curr_sound_type);
1438         }
1439
1440         stop_wav();
1441
1442         elm_naviframe_item_pop(ad->nf);
1443 }
1444
1445
1446 void _show_system_popup(void *data, Evas_Object *obj, void *event_info)
1447 {
1448         Evas_Object *ly;
1449         Evas_Object *btn;
1450         appdata *ad = data;
1451         int sound_mode;
1452
1453         if (ad == NULL)
1454                 return;
1455
1456         original_sound_mode = get_sound_mode();
1457
1458         curr_sound_type = SOUND_TYPE_SYSTEM;
1459
1460         vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_SOUND_VOLUME_INT, &volume_index);
1461
1462         DBG("Setting - Notification volume is %d", volume_index);
1463         sound_mode = get_sound_mode();
1464
1465         int real_volume_index = 0;
1466         sound_manager_get_volume(SOUND_TYPE_SYSTEM, &real_volume_index);
1467
1468         int virtual_index = real_volume_index;
1469
1470         DBG("Setting - vconf vol: %d, real vol: %d", volume_index, real_volume_index);
1471         if (sound_mode != SOUND_MODE_SOUND)
1472                 virtual_index = 0;
1473         else {
1474                 DBG("Sound Mode is - %d ", sound_mode);
1475         }
1476
1477         /* sync volume */
1478         volume_index = sync_volume(volume_index, virtual_index);
1479         original_volume = real_volume_index;
1480
1481         ad->MENU_TYPE = SETTING_VOLUME_2_DEPTH;
1482
1483         ly = elm_layout_add(ad->nf);
1484 #ifdef O_TYPE
1485         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default2");
1486 #else
1487         elm_layout_file_set(ly, EDJE_PATH, "setting/2finger_popup/default3");
1488 #endif
1489         evas_object_size_hint_weight_set(ly, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1490         evas_object_size_hint_align_set(ly, EVAS_HINT_FILL, EVAS_HINT_FILL);
1491
1492         int w, h;
1493         ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1494         DBG("    ----> width : %d,  height : %d ", w, h);
1495         if (w == 360 && h == 480) {
1496                 DBG("make long height !!!!!!!!!!!!!!!!!");
1497                 /*elm_object_signal_emit(layout, "set,popup,long", "elm.icon.1"); */
1498                 elm_object_signal_emit(ly, "set,popup,long", "*");
1499         }
1500 #ifdef O_TYPE
1501         Evas_Object *label = elm_label_add(ly);
1502         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1503         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
1504
1505         char *tempbuf[128];
1506         snprintf(tempbuf, sizeof(tempbuf) - 1, "%d", volume_index);
1507         elm_object_text_set(label, tempbuf);
1508         evas_object_resize(label, 200, 200);
1509         elm_object_part_content_set(ly, "elm.icon.2", label);
1510         if (get_sound_mode() != SOUND_MODE_SOUND)
1511                 evas_object_color_set(label, 83, 94, 102, 255);
1512
1513         evas_object_show(label);
1514
1515         Evas_Object *slider = eext_circle_object_slider_add(ly, ad->circle_surface);
1516
1517         eext_circle_object_value_min_max_set(slider, 0.0, 15.0);
1518         eext_circle_object_value_set(slider, volume_index);
1519
1520         eext_rotary_object_event_activated_set(slider, EINA_TRUE);
1521         eext_circle_object_slider_step_set(slider, 1);
1522         evas_object_smart_callback_add(slider, "value,changed", ringtone_value_changed, label);
1523 #else
1524
1525
1526         Evas_Object *spinner = elm_spinner_add(ly);
1527
1528         g_volume_spinner = spinner;
1529
1530         DBG("Setting- Volume: %d", volume_index);
1531
1532         /*elm_object_style_set(spinner, "volumestyle"); */
1533         elm_spinner_editable_set(spinner, EINA_FALSE);
1534         elm_spinner_min_max_set(spinner, 0, 15);
1535
1536         if (get_sound_mode() != SOUND_MODE_SOUND) {
1537                 elm_spinner_value_set(spinner, volume_index);
1538                 edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,min", "elm");
1539                 edje_object_part_drag_value_set(elm_layout_edje_get(spinner), "elm.dragable.slider", 0, 0);
1540
1541                 if (get_sound_mode() == SOUND_MODE_VIBRATE) {
1542                         edje_object_signal_emit(elm_layout_edje_get(spinner), "elm,spinner,vibrate", "elm");
1543                 }
1544
1545                 elm_object_disabled_set(spinner, EINA_TRUE);
1546         } else {
1547                 elm_spinner_value_set(spinner, volume_index);
1548                 _update_volume_circle(spinner);
1549         }
1550         evas_object_smart_callback_add(spinner, "changed", _on_media_volume_spinner_change_cb, ly);
1551         elm_object_part_content_set(ly, "elm.icon.1", spinner);
1552 #endif
1553         btn = elm_button_add(ly);
1554         elm_object_style_set(btn, "default");
1555         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1556         elm_object_translatable_text_set(btn, "IDS_ST_BUTTON_CANCEL_ABB2");
1557         elm_object_part_content_set(ly, "btn1", btn);
1558         evas_object_smart_callback_add(btn, "clicked", _set_cancel_cb, ad);
1559
1560         btn = elm_button_add(ly);
1561         elm_object_style_set(btn, "default");
1562         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1563         elm_object_translatable_text_set(btn, "IDS_WNOTI_BUTTON_OK_ABB2");
1564         elm_object_part_content_set(ly, "btn2", btn);
1565         evas_object_smart_callback_add(btn, "clicked", _set_system_clicked_cb, ad);
1566
1567         Elm_Object_Item *nf_it = elm_naviframe_item_push(ad->nf,
1568                                                                                                          "IDS_ST_BODY_SYSTEM_M_VOLUME_ABB",
1569                                                                                                          NULL, NULL,
1570                                                                                                          ly, NULL);
1571         elm_object_item_domain_text_translatable_set(nf_it, SETTING_PACKAGE, EINA_TRUE);
1572         elm_naviframe_item_pop_cb_set(nf_it, _back_volume_naviframe_cb, ad);
1573
1574         register_vconf_changing(VCONFKEY_PM_STATE, pm_state_vconf_changed_cb_for_volume, NULL);
1575
1576         sound_manager_set_volume_changed_cb(_media_volume_changed_cb, NULL);
1577
1578         /* Unregister sound mode vconf callback */
1579         register_vconf_changing(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibrate_vconf_changed_cb, NULL);
1580         register_vconf_changing(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL , sound_vconf_changed_cb, NULL);
1581 }