setting-profile/src/setting-profile-common.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <setting-profile.h>
  23 #include <sys/stat.h>
  24 #include <dirent.h>
  25 #include <iniparser.h>
  26 #include <utilX.h>
  27 #include <Ecore_X.h>
  28 #include <app_manager.h>
  29 #include <metadata_extractor.h>
  30 #include <player.h>
  31 #include <sound_manager_internal.h>
  32
  33 #define PLAY_FEEDBACK(f_type, f_pattern) {\
  34                 if (feedback_initialize() == FEEDBACK_ERROR_NONE) {\
  35                         feedback_play_type(f_type, f_pattern);\
  36                         feedback_deinitialize();\
  37                 } \
  38         }
  39
  40 typedef struct _SliderIcons {
  41         int index;
  42         char mute[256];
  43         char volume[256];
  44 } SliderIcons;
  45
  46 SliderIcons slider_icons[SND_SLIDER_MAX] = {
  47         {SND_SLIDER_CALL,       ICON_CALL_MUTE,         ICON_CALL_NORMAL},
  48         {SND_SLIDER_NOTI,       ICON_NOTI_MUTE,         ICON_NOTI_NORMAL},
  49         {SND_SLIDER_MEDIA,      ICON_MEDIA_MUTE,        ICON_MEDIA_NORMAL},
  50         {SND_SLIDER_SYSTEM,     ICON_SYSTEM_MUTE,       ICON_SYSTEM_NORMAL},
  51         /*{SND_SLIDER_MAX,      "",                     ""} */
  52 };
  53
  54 char *setting_sound_get_slider_icon(int type, int volume)
  55 {
  56         if (type < SND_SLIDER_CALL || type >= SND_SLIDER_MAX)
  57                 return NULL;
  58
  59         SETTING_TRACE("type : %d, volume : %d", type, volume);
  60         /* 1.Call ringtone has 3 icon status */
  61         if (SND_SLIDER_CALL == type) {
  62                 /*special process */
  63                 int sound = 0;
  64                 int vibration = 0;
  65                 vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &sound);
  66                 vconf_get_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vibration);
  67
  68                 if (sound && !vibration)
  69                         return ICON_CALL_NORMAL;
  70                 else if (vibration && !sound)
  71                         return ICON_CALL_VIB;
  72                 else if (!vibration && !sound)
  73                         return ICON_CALL_MUTE;
  74
  75                 return ICON_CALL_NORMAL;
  76         }
  77
  78         /* 2.Other types, just have two icon status */
  79         if (volume > 0) {
  80                 return slider_icons[type].volume;
  81         } else {
  82                 return slider_icons[type].mute;
  83         }
  84 }
  85
  86 void setting_sound_update_slider_icon(Setting_GenGroupItem_Data *item_data, int type)
  87 {
  88         SETTING_TRACE_BEGIN;
  89         ret_if(!item_data || !item_data->eo_check);
  90
  91         Evas_Object *icon = elm_object_content_get(item_data->eo_check);
  92         if (icon) {
  93                 char *new_file = setting_sound_get_slider_icon(type, item_data->chk_status);
  94                 elm_image_file_set(icon, new_file, NULL);
  95         }
  96 }
  97
  98 char *setting_media_basename(char *path)
  99 {
 100         if (NULL == path || '\0' == path[0]) {
 101                 return NULL;    /* invalid arguement */
 102         }
 103
 104         if (safeStrCmp(path, "silent") == 0)
 105                 return (char *)g_strdup(_("IDS_ST_BODY_PHONEPROFILES_SILENT"));
 106
 107         metadata_extractor_h metadata = NULL;
 108         char *title = NULL;
 109         int ret = metadata_extractor_create(&metadata);
 110         if (ret == METADATA_EXTRACTOR_ERROR_NONE && metadata) {
 111                 ret = metadata_extractor_set_path(metadata, path);
 112                 if (ret == METADATA_EXTRACTOR_ERROR_NONE) {
 113                         ret = metadata_extractor_get_metadata(metadata, METADATA_TITLE, &title);
 114                         metadata_extractor_destroy(metadata);
 115                         if (title) {
 116                                 char *strdup_title = (char *)g_strdup(title);
 117                                 FREE(title);
 118                                 return strdup_title;
 119                         } else {
 120                                 return setting_file_basename(path);
 121                         }
 122                 } else {
 123                         metadata_extractor_destroy(metadata);
 124                         return setting_file_basename(path);
 125                 }
 126         } else {
 127                 return setting_file_basename(path);
 128         }
 129 }
 130
 131 // -------------------------------------------------------------------------------------------
 132 // |                  | elm.swallow.icon.0 | elm.text | elm.swallow.icon.1 |                 |
 133 // | elm.swallow.icon |----------------------------------------------------| elm.swallow.end |
 134 // |                  |         elm.text.sub          | elm.text.sub.end   |                 |
 135 // -------------------------------------------------------------------------------------------
 136 static Evas_Object *__sound_slider_new_icon_get(void *data, Evas_Object *obj, const char *part)
 137 {
 138         SETTING_TRACE_BEGIN;
 139         /*appcore_measure_start(); */
 140         retv_if(data == NULL, NULL);
 141
 142         SETTING_TRACE(" -----------------> EDC part [%s]", part);
 143         if (! safeStrCmp(part, "elm.swallow.content")) {
 144
 145                 Evas_Object *layout;
 146                 // Set custom layout style
 147                 layout = elm_layout_add(obj);
 148
 149                 Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *)data;
 150                 Evas_Object *slider = setting_create_slider(obj, item_data->evas,
 151                                                                                                         item_data->l_swallow_path,
 152                                                                                                         item_data->r_swallow_path,
 153                                                                                                         item_data->chk_status,
 154                                                                                                         item_data->isIndicatorVisible,
 155                                                                                                         item_data->slider_min,
 156                                                                                                         item_data->slider_max,
 157                                                                                                         item_data->chk_change_cb,
 158                                                                                                         item_data->start_change_cb,
 159                                                                                                         item_data->stop_change_cb,
 160                                                                                                         item_data);
 161
 162                 if (slider == NULL)
 163                         return NULL;
 164
 165                 char* gl_style = "gl_custom_item";
 166                 elm_layout_file_set(layout, SETTING_THEME_EDJ_NAME, gl_style);
 167                 evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 168                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 169
 170                 if (0 == safeStrCmp(item_data->keyStr, "IDS_ST_BODY_MEDIA")) {
 171                         elm_object_style_set(slider, "warning");
 172
 173                         Edje_Message_Float_Set *msg = alloca(sizeof(Edje_Message_Float_Set) + (sizeof(double)));
 174                         msg->count = 1;
 175                         /* Warning area point has to be calculated considering rounding off.
 176                          * For example, value 10's area will be 9.5~10.4.
 177                          * So, if warning area has to be started at 10, we need to calculate the start point with 9.5.
 178                          * Warning start point = (Warning min value - 0.5) / (Max_Value - Min_Value) */
 179                         msg->val[0] = 0.633333;
 180                         edje_object_message_send(_EDJ(slider), EDJE_MESSAGE_FLOAT_SET, 0, msg);
 181                         elm_slider_indicator_format_set(slider, "%1.0f");
 182                         elm_slider_indicator_show_set(slider, 1);
 183                 }
 184
 185                 item_data->eo_check = slider;
 186
 187                 evas_object_pass_events_set(slider, EINA_TRUE);
 188                 evas_object_propagate_events_set(slider, EINA_FALSE);
 189
 190                 if (item_data->userdata == NULL)
 191                         return NULL;
 192
 193                 /* Set text into layout */
 194                 //if (0 == safeStrCmp(item_data->keyStr, "IDS_ST_BODY_MEDIA")
 195                 //      || 0 == safeStrCmp(item_data->keyStr, "IDS_ST_BODY_SYSTEM")) {
 196                         elm_object_part_text_set(layout, "elm.text", _(item_data->keyStr));
 197                 //}
 198                 elm_object_part_content_set(layout, "elm.swallow.content", slider);
 199                 return layout;
 200         }
 201         return NULL;
 202 }
 203
 204
 205
 206 static Evas_Object *__sound_slider_icon_get(void *data, Evas_Object *obj, const char *part)
 207 {
 208         /*SETTING_TRACE_BEGIN; */
 209         /*appcore_measure_start(); */
 210         retv_if(data == NULL, NULL);
 211
 212         if (safeStrCmp(part, "elm.icon")) {
 213                 /*SETTING_TRACE("EDC part [%s]", part); */
 214                 return NULL;
 215         }
 216
 217         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *)data;
 218         Evas_Object *slider = setting_create_slider(obj, item_data->evas,
 219                                                     item_data->l_swallow_path,
 220                                                     item_data->r_swallow_path,
 221                                                     item_data->chk_status,
 222                                                     item_data->isIndicatorVisible,
 223                                                     item_data->slider_min,
 224                                                     item_data->slider_max,
 225                                                     item_data->chk_change_cb,
 226                                                     item_data->start_change_cb,
 227                                                     item_data->stop_change_cb,
 228                                                     item_data);
 229
 230         if (slider == NULL)
 231                 return NULL;
 232         if (0 == safeStrCmp(item_data->keyStr, "IDS_ST_BODY_MEDIA")) {
 233                 elm_object_style_set(slider, "warning");
 234
 235                 Edje_Message_Float_Set *msg = alloca(sizeof(Edje_Message_Float_Set) + (sizeof(double)));
 236                 msg->count = 1;
 237                 msg->val[0] = 0.66667;
 238                 edje_object_message_send(_EDJ(slider), EDJE_MESSAGE_FLOAT_SET, 0, msg);
 239                 elm_slider_indicator_format_set(slider, "%1.0f");
 240                 elm_slider_indicator_show_set(slider, 1);
 241         }
 242
 243         item_data->eo_check = slider;
 244
 245         evas_object_pass_events_set(slider, EINA_TRUE);
 246         evas_object_propagate_events_set(slider, EINA_FALSE);
 247
 248         if (item_data->userdata == NULL)
 249                 return NULL;
 250
 251         return slider;
 252 }
 253
 254 /* ***************************************************
 255  *
 256  *general func
 257  *
 258  ***************************************************/
 259 #define SETTING_DEFAULT_FOLDER_PATH     "/opt/usr/share/settings/" /*resolve P130805-7070 */
 260 #define SDCARD_PATH     "/opt/storage/sdcard/"
 261
 262 int setting_sound_check_file_exist(void *data, const char *file_path)
 263 {
 264         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 265         retv_if(file_path == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 266
 267         /*resolve P130805-7070 */
 268         if (0 == safeStrNCmp(file_path, SETTING_DEFAULT_FOLDER_PATH, safeStrLen(SETTING_DEFAULT_FOLDER_PATH))) {
 269                 SETTING_TRACE("Default file[%s]!", file_path);
 270                 return SETTING_RETURN_SUCCESS;
 271         }
 272
 273         if (!ecore_file_exists(file_path)) {
 274                 if (safeStrCmp(file_path, "silent") == 0) {
 275                         SETTING_TRACE("%s", file_path);
 276                         return SETTING_RETURN_SUCCESS;
 277                 }
 278                 SETTING_TRACE_ERROR("Cannot find the ringtone file[%s]!", file_path);
 279                 if (0 == safeStrNCmp(file_path, SDCARD_PATH, safeStrLen(SDCARD_PATH))) {
 280                         char *strdup_file_path = strdup(file_path);
 281                         /*sdcard file*/
 282                         int ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_STR, strdup_file_path);
 283                         if (ret < 0) {
 284                                 SETTING_TRACE_DEBUG("failed to set vconf");
 285                         }
 286                         FREE(strdup_file_path);
 287                 }
 288                 return SETTING_RETURN_FAIL;
 289         }
 290
 291         int mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
 292         vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_status);
 293         if (VCONFKEY_SYSMAN_MMC_MOUNTED != mmc_status) {
 294                 if (!safeStrNCmp(SETTING_PROFILE_MMC_PATH, file_path, safeStrLen(SETTING_PROFILE_MMC_PATH))) {
 295                         return SETTING_RETURN_FAIL;
 296                 }
 297         }
 298         return SETTING_RETURN_SUCCESS;
 299 }
 300
 301 static void __enable_sound_menu(void *data)
 302 {
 303         SETTING_TRACE_BEGIN;
 304         ret_if(!data);
 305         SettingProfileUG *ad = data;
 306         ad->sound_on = TRUE;
 307         Setting_GenGroupItem_Data *item_to_update = NULL;
 308
 309
 310         /*1.Enable "Vibrate when ringing" */
 311         item_to_update = ad->data_sound_when_ring;
 312         setting_genlist_item_disabled_set(item_to_update, EINA_FALSE);
 313
 314
 315         /*2.Enable "Notification", via Sound Manager */
 316         item_to_update = ad->data_noti_volume;
 317         if (item_to_update && item_to_update->item && item_to_update->eo_check) {
 318                 int mm_value = 0;
 319                 int ret =  sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &mm_value);
 320                 SETTING_TRACE("ret:%d", ret);
 321                 item_to_update->chk_status = mm_value;
 322                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 323                 elm_object_item_disabled_set(item_to_update->item, EINA_FALSE);
 324                 elm_object_disabled_set(item_to_update->eo_check, EINA_FALSE);
 325
 326                 setting_sound_update_slider_icon(item_to_update, SND_SLIDER_NOTI);
 327         }
 328
 329
 330         /*3.Enable "System", via Sound Manager */
 331         item_to_update = ad->data_touch_volume;
 332         if (item_to_update && item_to_update->item && item_to_update->eo_check) {
 333                 int mm_value = 0;
 334                 int ret =  sound_manager_get_volume(SOUND_TYPE_SYSTEM, &mm_value);
 335                 SETTING_TRACE("ret:%d", ret);
 336                 item_to_update->chk_status = mm_value;
 337                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 338                 elm_object_item_disabled_set(item_to_update->item, EINA_FALSE);
 339                 elm_object_disabled_set(item_to_update->eo_check, EINA_FALSE);
 340
 341                 setting_sound_update_slider_icon(item_to_update, SND_SLIDER_SYSTEM);
 342         }
 343
 344
 345         /*4.Enable "Call ringtone", via "Backuped" value */
 346         item_to_update = ad->data_call_volume;
 347         if (item_to_update && item_to_update->eo_check) {
 348                 SETTING_TRACE("....ad->is_ringtone_slidering:%d, ad->data_call_volume->chk_status:%d",
 349                               ad->is_ringtone_slidering, item_to_update->chk_status);
 350                 if (ad->is_ringtone_slidering) return;/*do need to restore from BACKUP VOLUME */
 351
 352                 int mm_value = 0;
 353                 int ret =  sound_manager_get_volume(SOUND_TYPE_RINGTONE, &mm_value);
 354                 if (mm_value <= 0) mm_value = 1;
 355                 /*SETTING_TRACE("ret:%d", ret); */
 356                 sound_manager_set_volume(SOUND_TYPE_RINGTONE, mm_value);
 357                 item_to_update->chk_status = mm_value;
 358                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 359                 SETTING_TRACE("ad->data_call_volume->chk_status : %d", item_to_update->chk_status);
 360         }
 361
 362 }
 363
 364 static void __disable_sound_menu(void *data)
 365 {
 366         SETTING_TRACE_BEGIN;
 367         ret_if(!data);
 368         SettingProfileUG *ad = data;
 369         ad->sound_on = FALSE;
 370
 371         __close_player(ad, SND_SLIDER_NOTI);
 372         __close_player(ad, SND_SLIDER_MEDIA);
 373
 374         if (ad->mp_ringtone) {
 375                 SETTING_TRACE_DEBUG("player_set_mute");
 376                 player_set_mute(*(ad->mp_ringtone), 1);
 377         }
 378         Setting_GenGroupItem_Data *item_to_update = NULL;
 379
 380         /*1.Disable  "Vibrate when ringing" */
 381         item_to_update = ad->data_sound_when_ring;
 382         setting_genlist_item_disabled_set(item_to_update, EINA_TRUE);
 383
 384         /*2.Disable "Notification" */
 385         item_to_update = ad->data_noti_volume;
 386         if (item_to_update && item_to_update->item && item_to_update->eo_check) {
 387                 item_to_update->chk_status = 0;
 388                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 389                 elm_object_item_disabled_set(item_to_update->item, EINA_TRUE);
 390                 elm_object_disabled_set(item_to_update->eo_check, EINA_TRUE);
 391
 392                 /* Change notification slider's icon as mute style */
 393                 setting_sound_update_slider_icon(item_to_update, SND_SLIDER_NOTI);
 394         }
 395
 396         /*3.Disable "System" */
 397         item_to_update = ad->data_touch_volume;
 398         if (item_to_update && item_to_update->item && item_to_update->eo_check) {
 399                 item_to_update->chk_status = 0;
 400                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 401                 elm_object_item_disabled_set(item_to_update->item, EINA_TRUE);
 402                 elm_object_disabled_set(item_to_update->eo_check, EINA_TRUE);
 403
 404                 /* Change system slider's icon as mute style */
 405                 setting_sound_update_slider_icon(item_to_update, SND_SLIDER_SYSTEM);
 406         }
 407
 408         /*4.Disable "Call ringtone" */
 409         item_to_update = ad->data_call_volume;
 410         if (item_to_update && item_to_update->eo_check) {
 411                 /*DO NOT CHANGE Backup Values(VCONFKEY_SETAPPL_RINGTONE_BACKUP_VOLUME) */
 412                 item_to_update->chk_status = 0;
 413                 elm_slider_value_set(item_to_update->eo_check, item_to_update->chk_status);
 414                 SETTING_TRACE("item_to_update->chk_status : %d", item_to_update->chk_status);
 415         }
 416
 417 }
 418
 419 static void ___sound_vconf_change_cb(keynode_t *key, void *data)
 420 {
 421         ret_if(data == NULL);
 422         SettingProfileUG *ad = data;
 423         int status = 0;
 424         int ret = 0;
 425         char *pa_ringtone = NULL;
 426         char *sub_desc = NULL;
 427         char *vconf_name = vconf_keynode_get_name(key);
 428         Setting_GenGroupItem_Data *item_to_update = NULL;
 429
 430         if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
 431                 status = vconf_keynode_get_int(key);
 432                 SETTING_TRACE("status:%d", status);
 433                 if (VCONFKEY_SYSMAN_MMC_MOUNTED != status) {
 434                         /* when remove mmc card, change default tone */
 435                         char *call_tone = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 436                         if (call_tone && !safeStrNCmp(SETTING_PROFILE_MMC_PATH, call_tone, safeStrLen(SETTING_PROFILE_MMC_PATH))) {
 437                                 if (isEmulBin()) {
 438                                         ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, SETTING_DEFAULT_CALL_TONE_SDK);
 439                                 } else {
 440                                         ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, SETTING_DEFAULT_CALL_TONE);
 441                                 }
 442                                 if (ret < 0)
 443                                         SETTING_TRACE_DEBUG("failed to set vconf");
 444                         }
 445                         FREE(call_tone);
 446
 447                         ret_if((!ad->mp_ringtone && !ad->mp_noti && !ad->mp_media));
 448                         SETTING_TRACE("song_playing:%s", ad->song_playing);
 449
 450                         if (!safeStrNCmp(SETTING_PROFILE_MMC_PATH, ad->song_playing, safeStrLen(SETTING_PROFILE_MMC_PATH))) {
 451                                 /*  close mm plaer */
 452                                 setting_sound_close_all_mm_players(ad);
 453                                 /*  close vibration */
 454                         }
 455                 }
 456         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_SOUND_STATUS_BOOL)) {
 457                 status = vconf_keynode_get_bool(key);
 458                 SETTING_TRACE_DEBUG("sound status is changed. %d", status);
 459                 if (status) {
 460                         __enable_sound_menu(ad);
 461                 } else {
 462                         __disable_sound_menu(ad);
 463                 }
 464
 465                 setting_sound_update_slider_icon(ad->data_call_volume, SND_SLIDER_CALL);
 466                 /*FIX P141016-02659 Only In sound mode should enable "vibrate when ringing" */
 467                 setting_genlist_item_disabled_set(ad->data_sound_when_ring, !status);
 468         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL)) {
 469                 status = vconf_keynode_get_bool(key);
 470                 SETTING_TRACE_DEBUG("vibration status is changed. %d", status);
 471                 if (status) {
 472                         PLAY_FEEDBACK(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_VIBRATION_ON)
 473                 }
 474
 475                 setting_sound_update_slider_icon(ad->data_call_volume, SND_SLIDER_CALL);
 476         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_VIBRATE_WHEN_RINGING_BOOL)) {
 477                 item_to_update = ad->data_sound_when_ring;
 478                 status = vconf_keynode_get_bool(key);
 479                 if (item_to_update && item_to_update->eo_check) {
 480                         item_to_update->chk_status = status;
 481                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 482                 }
 483         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_BUTTON_SOUNDS_BOOL)) {
 484                 item_to_update = ad->data_button_sounds;
 485                 status = vconf_keynode_get_bool(key);
 486                 if (item_to_update && item_to_update->eo_check) {
 487                         item_to_update->chk_status = status;
 488                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 489                 }
 490         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL)) {
 491                 item_to_update = ad->data_touch_sounds;
 492                 status = vconf_keynode_get_bool(key);
 493                 if (item_to_update && item_to_update->eo_check) {
 494                         item_to_update->chk_status = status;
 495                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 496                 }
 497         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_SOUND_LOCK_BOOL)) {
 498                 item_to_update = ad->data_lock_sound;
 499                 status = vconf_keynode_get_bool(key);
 500                 if (item_to_update && item_to_update->eo_check) {
 501                         item_to_update->chk_status = status;
 502                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 503                 }
 504         }
 505 #if 0
 506         else if (!safeStrCmp(vconf_name, VCONFKEY_ISE_KEYSOUND)) {
 507                 item_to_update = ad->data_keyboard_sound;
 508                 status = vconf_keynode_get_bool(key);
 509                 if (item_to_update && item_to_update->eo_check) {
 510                         item_to_update->chk_status = status;
 511                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 512                 }
 513         }
 514 #endif
 515         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR)) {
 516                 item_to_update = ad->data_call_alert_tone;
 517
 518                 pa_ringtone = (char *)g_strdup(vconf_keynode_get_str(key));
 519                 if (setting_sound_check_file_exist(ad, pa_ringtone) == SETTING_RETURN_FAIL) {
 520                         if (isEmulBin()) {
 521                                 G_FREE(pa_ringtone);
 522                                 pa_ringtone = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE_SDK);
 523                         } else {
 524                                 G_FREE(pa_ringtone);
 525                                 pa_ringtone = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
 526                         }
 527                         ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, pa_ringtone);
 528                         if (ret < 0)
 529                                 SETTING_TRACE_DEBUG("failed to set vconf");
 530                 }
 531                 sub_desc = setting_media_basename(pa_ringtone);
 532                 if (item_to_update) {
 533                         item_to_update->sub_desc = (char *)g_strdup(sub_desc);
 534                         elm_genlist_item_update(item_to_update->item);
 535                 }
 536                 G_FREE(pa_ringtone);
 537                 G_FREE(sub_desc);
 538         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR)) {
 539                 item_to_update = ad->data_msg_alert_tone;
 540                 pa_ringtone = (char *)g_strdup(vconf_keynode_get_str(key));
 541                 if (setting_sound_check_file_exist(ad, pa_ringtone) == SETTING_RETURN_FAIL) {
 542                         G_FREE(pa_ringtone);
 543                         pa_ringtone = (char *)g_strdup(SETTING_DEFAULT_MSG_TONE);
 544                         ret = vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, pa_ringtone);
 545                         if (ret < 0)
 546                                 SETTING_TRACE_DEBUG("failed to set vconf");
 547                 }
 548                 sub_desc = setting_media_basename(pa_ringtone);
 549                 if (item_to_update) {
 550                         item_to_update->sub_desc = (char *)g_strdup(sub_desc);
 551                         elm_genlist_item_update(item_to_update->item);
 552                 }
 553                 G_FREE(pa_ringtone);
 554                 G_FREE(sub_desc);
 555         }
 556 }
 557
 558 int setting_sound_listen_vconf_change(void *data)
 559 {
 560         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 561
 562         /*Ints */
 563         (void)vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS, ___sound_vconf_change_cb, data);
 564
 565         /*Bools */
 566         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, ___sound_vconf_change_cb, data);
 567         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, ___sound_vconf_change_cb, data);
 568
 569         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_RINGING_BOOL, ___sound_vconf_change_cb, data);
 570         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_BUTTON_SOUNDS_BOOL, ___sound_vconf_change_cb, data);
 571         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, ___sound_vconf_change_cb, data);
 572         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, ___sound_vconf_change_cb, data);
 573         /*      (void)vconf_notify_key_changed(VCONFKEY_ISE_KEYSOUND, ___sound_vconf_change_cb, data); */
 574
 575         /*Strings */
 576         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, ___sound_vconf_change_cb, data);
 577         (void)vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, ___sound_vconf_change_cb, data);
 578
 579         return 0;
 580 }
 581
 582 int setting_sound_unlisten_vconf_change(void *data)
 583 {
 584         /* unused listen */
 585         /*Ints */
 586         (void)vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS, ___sound_vconf_change_cb);
 587
 588         /*Bools */
 589         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, ___sound_vconf_change_cb);
 590         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, ___sound_vconf_change_cb);
 591
 592         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_RINGING_BOOL, ___sound_vconf_change_cb);
 593         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_BUTTON_SOUNDS_BOOL, ___sound_vconf_change_cb);
 594         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, ___sound_vconf_change_cb);
 595         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, ___sound_vconf_change_cb);
 596         /*(void)vconf_ignore_key_changed(VCONFKEY_ISE_KEYSOUND, ___sound_vconf_change_cb); */
 597
 598         /*Strings */
 599         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, ___sound_vconf_change_cb);
 600         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, ___sound_vconf_change_cb);
 601         return 0;
 602 }
 603
 604 static Eina_Bool __volume_up_timer_cb(void *data)
 605 {
 606         SETTING_TRACE_BEGIN;
 607         retv_if(!data, EINA_FALSE);
 608         SettingProfileUG *ad = (SettingProfileUG *)data;
 609
 610         if (ad->is_pressing == FALSE) {
 611                 ad->updown_timer = NULL;
 612                 return EINA_FALSE;
 613         }
 614
 615         sound_type_e sound_type = 0;
 616         int volume = 0;
 617         sound_manager_get_current_sound_type(&sound_type);
 618         if (sound_type == SOUND_TYPE_MEDIA) {
 619                 int ret =  sound_manager_get_volume(sound_type, &volume);
 620                 SETTING_TRACE("ret:%d", ret);
 621                 if (volume < 15) {
 622                         sound_manager_set_volume(sound_type, ++volume);
 623                         if (ad->data_media_volume && ad->data_media_volume->eo_check) {
 624                                 ad->data_media_volume->chk_status = volume;
 625                                 elm_slider_value_set(ad->data_media_volume->eo_check, volume);
 626                         }
 627                 }
 628         } else {
 629                 int ret =  sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume);
 630                 SETTING_TRACE("ret:%d", ret);
 631                 if (volume < 15) {
 632                         sound_manager_set_volume(SOUND_TYPE_RINGTONE, ++volume);
 633                         if (ad->data_call_volume && ad->data_call_volume->eo_check) {
 634                                 ad->data_call_volume->chk_status = volume;
 635                                 elm_slider_value_set(ad->data_call_volume->eo_check, volume);
 636                                 SETTING_TRACE("ad->data_call_volume->chk_status : %d", ad->data_call_volume->chk_status);
 637                         }
 638                 }
 639         }
 640
 641         return EINA_TRUE;
 642 }
 643
 644 static Eina_Bool __volume_down_timer_cb(void *data)
 645 {
 646         SETTING_TRACE_BEGIN;
 647         retv_if(!data, EINA_FALSE);
 648         SettingProfileUG *ad = (SettingProfileUG *)data;
 649
 650         if (ad->is_pressing == FALSE) {
 651                 ad->updown_timer = NULL;
 652                 return EINA_FALSE;
 653         }
 654
 655         sound_type_e sound_type = 0;
 656         int volume = 0;
 657         sound_manager_get_current_sound_type(&sound_type);
 658         if (sound_type == SOUND_TYPE_MEDIA) {
 659                 int ret =  sound_manager_get_volume(sound_type, &volume);
 660                 SETTING_TRACE("ret:%d", ret);
 661                 if (volume > 0) {
 662                         sound_manager_set_volume(sound_type, --volume);
 663                         if (ad->data_media_volume && ad->data_media_volume->eo_check) {
 664                                 ad->data_media_volume->chk_status = volume;
 665                                 elm_slider_value_set(ad->data_media_volume->eo_check, volume);
 666                         }
 667                 }
 668         } else {
 669                 int ret =  sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume);
 670                 SETTING_TRACE("ret:%d", ret);
 671                 if (volume > 0) {
 672                         sound_manager_set_volume(SOUND_TYPE_RINGTONE, --volume);
 673                         if (volume == 0) {
 674                                 /* change to Vibration mode */
 675                                 vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 676                                 vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 677                                 PLAY_FEEDBACK(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_VIBRATION_ON);
 678                         }
 679                         if (ad->data_call_volume && ad->data_call_volume->eo_check) {
 680                                 ad->data_call_volume->chk_status = volume;
 681                                 elm_slider_value_set(ad->data_call_volume->eo_check, volume);
 682                                 SETTING_TRACE("ad->data_call_volume->chk_status : %d", ad->data_call_volume->chk_status);
 683                                 setting_sound_update_slider_icon(ad->data_call_volume, SND_SLIDER_CALL);
 684                         }
 685                 }
 686         }
 687
 688         return EINA_TRUE;
 689 }
 690
 691 static Eina_Bool __volume_key_up_cb(void *data, int type, void *event)
 692 {
 693         SETTING_TRACE_BEGIN;
 694         retv_if(!data || !event, EINA_TRUE);
 695         SettingProfileUG *ad = (SettingProfileUG *)data;
 696
 697         Ecore_Event_Key *ev = event;
 698         char *key = (char *)ev->key;
 699         if (!key)
 700                 return EINA_TRUE;
 701
 702         if (!safeStrCmp(key, "XF86AudioRaiseVolume") || !safeStrCmp(key, "XF86AudioLowerVolume")) {
 703                 ad->is_pressing = FALSE;
 704                 if (ad->updown_timer) {
 705                         ecore_timer_del(ad->updown_timer);
 706                         ad->updown_timer = NULL;
 707                 }
 708         }
 709         return EINA_TRUE;
 710 }
 711
 712 static Eina_Bool __volume_key_down_cb(void *data, int type, void *event)
 713 {
 714         SETTING_TRACE_BEGIN;
 715         retv_if(!data || !event, EINA_TRUE);
 716         SettingProfileUG *ad = (SettingProfileUG *)data;
 717
 718         Ecore_Event_Key *ev = event;
 719         char *key = (char *)ev->key;
 720         if (!key)
 721                 return EINA_TRUE;
 722
 723         /* get current sound type */
 724         sound_type_e sound_type;
 725         int volume = 0;
 726
 727         if (!safeStrCmp(key, "XF86AudioRaiseVolume")) {
 728                 SETTING_TRACE("Press KEY_VOLUMEUP");
 729                 /*
 730                  * S5 concept:
 731                  * On the volume popup,
 732                  *  1) if user controls the slider, don't play any sounds��just change volume.
 733                  *  2) if user controls the HW volume key for ringtone sound, the beep sound is supported
 734
 735                  * On Setting > Sound
 736                  *  1) if user controls the slider, change volume & play sound
 737                  *  2) if user controls the HW volume key, do nothing(DO NOT change volume,DO NoT play sound)
 738                 */
 739                 if (0 != safeStrCmp(ad->viewtype, VOLUME_APP_NAME)) {
 740                         return EINA_TRUE;
 741                 }
 742
 743                 /*if (ad->view_type != SETTING_PROF_VIEW_VOL) return EINA_TRUE; */
 744
 745                 ad->is_pressing = TRUE;
 746
 747                 sound_manager_get_current_sound_type(&sound_type);
 748                 if (sound_type == SOUND_TYPE_MEDIA) {
 749                         SETTING_TRACE("sound_type == SOUND_TYPE_MEDIA")
 750                         int ret =  sound_manager_get_volume(sound_type, &volume);
 751                         SETTING_TRACE("ret:%d", ret);
 752                         if (volume < 15) {
 753                                 ++volume;
 754                                 int ret = sound_manager_set_volume(sound_type, volume);
 755
 756                                 if (/*ret == SOUND_MANAGER_ERROR_NO_OPERATION ||*/ ret == SOUND_MANAGER_ERROR_INTERNAL) {
 757                                         SETTING_TRACE_DEBUG("didn't set volume");
 758                                         if (volume > 10) {
 759                                                 ad->data_media_volume->chk_status = 10;
 760                                                 elm_slider_value_set(ad->data_media_volume->eo_check, 10);
 761                                                 return EINA_TRUE;
 762                                         }
 763                                 }
 764
 765                                 if (ad->data_media_volume && ad->data_media_volume->eo_check) {
 766                                         ad->data_media_volume->chk_status = volume;
 767                                         elm_slider_value_set(ad->data_media_volume->eo_check, volume);
 768                                 }
 769                         }
 770                 } else {
 771                         SETTING_TRACE("sound_type == SOUND_TYPE_RINGTONE")
 772                         int ret =  sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume);
 773                         /*ad->backup_ringtong_volume = volume; */
 774                         /*vconf_set_int(VCONFKEY_SETAPPL_RINGTONE_BACKUP_VOLUME, ad->backup_ringtong_volume); */
 775                         /*SETTING_TRACE("ret:%d, volume:%d, ad->backup_ringtong_volume:%d", ret, volume, ad->backup_ringtong_volume); */
 776                         if (volume < 15) {
 777                                 sound_manager_set_volume(SOUND_TYPE_RINGTONE, ++volume);
 778
 779                                 int sound = 0;
 780                                 vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &sound);
 781                                 if (volume > 0 && !sound) {
 782                                         vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
 783                                         vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE);
 784                                         ad->data_call_volume->chk_status = volume;
 785                                         setting_sound_update_slider_icon(ad->data_call_volume, SND_SLIDER_CALL);
 786                                 }
 787                                 if (ad->data_call_volume && ad->data_call_volume->eo_check) {
 788                                         ad->data_call_volume->chk_status = volume;
 789                                         elm_slider_value_set(ad->data_call_volume->eo_check, volume);
 790                                         SETTING_TRACE("ad->data_call_volume->chk_status : %d", ad->data_call_volume->chk_status);
 791                                 }
 792                         }
 793
 794                         SETTING_TRACE("ad->mp_ringtone:%p, volume:%d", ad->mp_ringtone, volume);
 795                         if (ad->mp_ringtone == NULL) {
 796                                 setting_sound_close_other_mm_players_but_type(ad, SOUND_TYPE_RINGTONE);
 797                                 if (volume > 0) {
 798                                         setting_sound_play_sound_origin(&(ad->mp_ringtone), ad, NULL,
 799                                                                         "/opt/usr/share/settings/Sys/Volume_control.ogg",
 800                                                                         volume,
 801                                                                         SOUND_TYPE_RINGTONE);
 802                                 }
 803                         } else {
 804                                 player_state_e state;
 805                                 player_get_state(*(ad->mp_ringtone), &state);
 806                                 if (state == PLAYER_STATE_PAUSED) {
 807                                         SETTING_TRACE("state == PLAYER_STATE_PAUSED");
 808                                         player_start(*(ad->mp_ringtone));
 809                                 } else if (state == PLAYER_STATE_PLAYING) {
 810                                         SETTING_TRACE("state == PLAYER_STATE_PLAYING");
 811                                         player_set_mute(*(ad->mp_ringtone), FALSE);
 812                                 }
 813                         }
 814                 }
 815                 ad->updown_timer = ecore_timer_add(0.5, __volume_up_timer_cb, ad);
 816         } else if (!safeStrCmp(key, "XF86AudioLowerVolume")) {
 817                 SETTING_TRACE("Press KEY_VOLUMEDOWN");
 818                 /*
 819                  * S5 concept:
 820                  * On the volume popup,
 821                  *  1) if user controls the slider, don't play any sounds��just change volume.
 822                  *  2) if user controls the HW volume key for ringtone sound, the beep sound is supported
 823
 824                  * On Setting > Sound
 825                  *  1) if user controls the slider, change volume & play sound
 826                  *  2) if user controls the HW volume key, do nothing(DO NOT change volume,DO NoT play sound)
 827                 */
 828                 if (0 != safeStrCmp(ad->viewtype, VOLUME_APP_NAME)) {
 829                         return EINA_TRUE;
 830                 }
 831                 /*if (ad->view_type != SETTING_PROF_VIEW_VOL) return EINA_TRUE; */
 832                 ad->is_pressing = TRUE;
 833                 sound_manager_get_current_sound_type(&sound_type);
 834                 if (sound_type == SOUND_TYPE_MEDIA) {
 835                         SETTING_TRACE("sound_type == SOUND_TYPE_MEDIA")
 836                         int ret =  sound_manager_get_volume(sound_type, &volume);
 837                         SETTING_TRACE("ret:%d", ret);
 838                         if (volume > 0) {
 839                                 sound_manager_set_volume(sound_type, --volume);
 840                                 if (ad->data_media_volume && ad->data_media_volume->eo_check) {
 841                                         ad->data_media_volume->chk_status = volume;
 842                                         elm_slider_value_set(ad->data_media_volume->eo_check, volume);
 843                                 }
 844                         }
 845                 } else {
 846
 847                         SETTING_TRACE("sound_type == SOUND_TYPE_RINGTONE");
 848                         int sound = 0;
 849                         vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &sound);
 850                         if (!sound) return EINA_TRUE;
 851                         int ret =  sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume);
 852                         SETTING_TRACE("ret:%d, volume:%d", ret, volume);
 853                         if (volume > 0) {
 854                                 sound_manager_set_volume(SOUND_TYPE_RINGTONE, --volume);
 855                                 if (volume == 0) {
 856                                         /* change to Vibration mode */
 857                                         vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, FALSE);
 858                                         vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, TRUE);
 859
 860                                         PLAY_FEEDBACK(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_VIBRATION_ON);
 861
 862                                         ad->data_call_volume->chk_status = volume;
 863                                         setting_sound_update_slider_icon(ad->data_call_volume, SND_SLIDER_CALL);
 864                                 }
 865                                 if (ad->data_call_volume && ad->data_call_volume->eo_check) {
 866                                         ad->data_call_volume->chk_status = volume;
 867                                         elm_slider_value_set(ad->data_call_volume->eo_check, volume);
 868                                         SETTING_TRACE("ad->data_call_volume->chk_status : %d", ad->data_call_volume->chk_status);
 869                                 }
 870                         }
 871                         if (ad->mp_ringtone == NULL) {
 872                                 setting_sound_close_other_mm_players_but_type(ad, SOUND_TYPE_RINGTONE);
 873                                 if (volume > 0) {
 874                                         setting_sound_play_sound_origin(&(ad->mp_ringtone), ad, NULL,
 875                                                                         "/opt/usr/share/settings/Sys/Volume_control.ogg",
 876                                                                         volume,
 877                                                                         SOUND_TYPE_RINGTONE);
 878                                 }
 879                         } else {
 880                                 player_state_e state;
 881                                 player_get_state(*(ad->mp_ringtone), &state);
 882                                 SETTING_TRACE("ringtone player status : %d", state);
 883                                 if (state == PLAYER_STATE_PAUSED) {
 884                                         player_start(*(ad->mp_ringtone));
 885                                 }
 886                         }
 887                 }
 888                 ad->updown_timer = ecore_timer_add(0.5, __volume_down_timer_cb, ad);
 889         } else if (!safeStrCmp(key, "XF86Menu")) {
 890                 SETTING_TRACE("KEY_MENU CLICK.");
 891         } else if (!safeStrCmp(key, "XF86Home")) { /*XF86Phone*/
 892                 SETTING_TRACE("KEY_HOME is pressed");
 893                 if (!safeStrCmp(ad->viewtype, "org.tizen.volume"))
 894                         ug_destroy_me(ad->ug);
 895         } else if (!safeStrCmp(key, "XF86Back")) { /*Back hard key*/
 896                 SETTING_TRACE(" Back is pressed");
 897                 /*SETTING_TRACE(" ad->viewtype %s", ad->viewtype);*/
 898                 /*if (!safeStrCmp(ad->viewtype, "org.tizen.volume"))*/
 899                 if (!safeStrCmp(ad->viewtype, "org.tizen.setting.volume")) {
 900                         /*ug_destroy_me(ad->ug);*/
 901                         elm_exit();
 902                 }
 903         }
 904
 905         return EINA_TRUE;
 906 }
 907
 908 void __setting_sound_ug_key_grab(SettingProfileUG *ad)
 909 {
 910         SETTING_TRACE_BEGIN;
 911         Ecore_X_Window xwin = 0;
 912         Ecore_X_Display *disp = NULL;
 913
 914         int ret = 0;
 915
 916         if (ad == NULL)
 917                 return;
 918
 919         /* To prevent conflict with volume app */
 920         vconf_set_int(VCONFKEY_STARTER_USE_VOLUME_KEY, 2);
 921
 922         disp = ecore_x_display_get();
 923         xwin = elm_win_xwindow_get(ad->win_get);
 924
 925         ret = eext_win_keygrab_set(xwin, "XF86AudioRaiseVolume");
 926         if (ret) {
 927                 SETTING_TRACE_DEBUG("KEY_VOLUMEUP grab failed");
 928         }
 929         ret = eext_win_keygrab_set(xwin, "XF86AudioLowerVolume");
 930         if (ret) {
 931                 SETTING_TRACE_DEBUG("KEY_VOLUMEDOWN grab failed");
 932         }
 933         if (ad->keydown_handler) {
 934                 ecore_event_handler_del(ad->keydown_handler);
 935                 ad->keydown_handler = NULL;
 936         }
 937         if (ad->keyup_handler) {
 938                 ecore_event_handler_del(ad->keyup_handler);
 939                 ad->keyup_handler = NULL;
 940         }
 941         ad->keydown_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, __volume_key_down_cb, ad);
 942         if (!ad->keydown_handler)
 943                 SETTING_TRACE_DEBUG("ecore_event_handler_add() failed");
 944
 945         ad->keyup_handler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, __volume_key_up_cb, ad);
 946         if (!ad->keyup_handler)
 947                 SETTING_TRACE_DEBUG("ecore_event_handler_add() failed");
 948
 949         SETTING_TRACE_END;
 950 }
 951
 952 void __setting_sound_ug_key_ungrab(SettingProfileUG *ad)
 953 {
 954         SETTING_TRACE_BEGIN;
 955         Ecore_X_Window xwin = 0;
 956         Ecore_X_Display *disp = NULL;
 957
 958         int ret = 0;
 959
 960         if (ad == NULL)
 961                 return;
 962
 963         /* To prevent conflict with volume app */
 964         vconf_set_int(VCONFKEY_STARTER_USE_VOLUME_KEY, 0);
 965
 966         disp = ecore_x_display_get();
 967         xwin = elm_win_xwindow_get(ad->win_get);
 968
 969         ret = eext_win_keygrab_unset(xwin, "XF86AudioRaiseVolume");
 970         if (ret) {
 971                 SETTING_TRACE_DEBUG("KEY_VOLUMEUP ungrab failed");
 972         }
 973         ret = eext_win_keygrab_unset(xwin, "XF86AudioLowerVolume");
 974         if (ret) {
 975                 SETTING_TRACE_DEBUG("KEY_VOLUMEDOWN ungrab failed");
 976         }
 977
 978         if (ad->updown_timer) {
 979                 ecore_timer_del(ad->updown_timer);
 980                 ad->updown_timer = NULL;
 981         }
 982         if (ad->keydown_handler) {
 983                 ecore_event_handler_del(ad->keydown_handler);
 984                 ad->keydown_handler = NULL;
 985         }
 986         if (ad->keyup_handler) {
 987                 ecore_event_handler_del(ad->keyup_handler);
 988                 ad->keyup_handler = NULL;
 989         }
 990 }
 991
 992 Evas_Object *setting_sound_init(void *data)
 993 {
 994         SETTING_TRACE_BEGIN;
 995         /*appcore_measure_start(); */
 996         retv_if(data == NULL, NULL);
 997         SettingProfileUG *ad = data;
 998
 999         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
1000
1001         setting_create_Gendial_itc(SETTING_GENLIST_LEFT_ICON_CONTENT_ICON_STYLE, &(ad->itc_layout));
1002
1003         #ifdef OLD_GENLIST_STYLE
1004         ad->itc_layout.func.content_get = __sound_slider_icon_get;
1005         #else
1006         ad->itc_layout.func.content_get = __sound_slider_new_icon_get;
1007         #endif
1008
1009         setting_create_Gendial_itc(SETTING_GENLIST_LEFT_ICON_CONTENT_ICON_STYLE, &(ad->itc_layout_1icon));
1010
1011         #ifdef OLD_GENLIST_STYLE
1012         ad->itc_layout_1icon.func.content_get = __sound_slider_icon_get;
1013         #else
1014         ad->itc_layout_1icon.func.content_get = __sound_slider_new_icon_get;
1015         #endif
1016
1017         /* register view node table */
1018         setting_view_node_table_intialize();
1019         setting_view_node_table_register(&setting_view_sound_main, NULL);
1020
1021         if (!safeStrCmp(ad->viewtype, VOLUME_APP_NAME))
1022                 elm_win_wm_rotation_preferred_rotation_set(ad->win_get, -1);
1023         else
1024                 elm_win_wm_rotation_preferred_rotation_set(ad->win_get, 0);
1025
1026         /* creating a view. */
1027         setting_view_node_set_cur_view(&setting_view_sound_main);
1028         setting_view_create(&setting_view_sound_main, (void *)ad);
1029
1030         setting_sound_listen_vconf_change(ad);
1031
1032         return ad->ly_main;
1033 }
1034
1035 void setting_sound_deinit(void *data)
1036 {
1037         SETTING_TRACE_BEGIN;
1038         ret_if(data == NULL);
1039         SettingProfileUG *ad = data;
1040         elm_win_wm_rotation_preferred_rotation_set(ad->win_get, -1);
1041
1042         setting_sound_unlisten_vconf_change(ad);
1043         setting_sound_close_all_mm_players(ad);
1044
1045         if (ad->calling_popup) {
1046                 evas_object_del(ad->calling_popup);
1047                 ad->calling_popup = NULL;
1048         }
1049
1050         if (ad->updown_timer) {
1051                 ecore_timer_del(ad->updown_timer);
1052                 ad->updown_timer = NULL;
1053         }
1054         if (ad->keydown_handler) {
1055                 ecore_event_handler_del(ad->keydown_handler);
1056                 ad->keydown_handler = NULL;
1057         }
1058         if (ad->keyup_handler) {
1059                 ecore_event_handler_del(ad->keyup_handler);
1060                 ad->keyup_handler = NULL;
1061         }
1062         FREE(ad->viewtype);
1063
1064         /* it is the view manage strategy to invoke view's destory operation. */
1065         setting_view_destroy(&setting_view_sound_main, ad);
1066
1067         SETTING_TRACE_END;
1068 }
1069
1070 /* ***************************************************
1071  *
1072  *general func
1073  *
1074  ***************************************************/
1075 static void __calling_popup_cb(void *data, Evas_Object *obj, void *event_info)
1076 {
1077         ret_if(data == NULL);
1078         SettingProfileUG *ad = (SettingProfileUG *) data;
1079
1080         if (ad->calling_popup) {
1081                 evas_object_del(ad->calling_popup);
1082                 ad->calling_popup = NULL;
1083         }
1084 }
1085
1086 /* Show guide popup, when drag or tap slider if during call.
1087         Do not provide pre-listening. */
1088 void setting_sound_create_warning_popup_during_call(void *data)
1089 {
1090         ret_if(data == NULL);
1091         SettingProfileUG *ad = (SettingProfileUG *) data;
1092
1093         int call_status = CM_CALL_STATUS_IDLE;
1094         cm_client_h cm_handle = NULL;
1095         cm_init(&cm_handle);
1096         cm_get_call_status(cm_handle, &call_status);
1097         cm_deinit(cm_handle);
1098         if (CM_CALL_STATUS_IDLE != call_status) {
1099                 SETTING_TRACE("Call status is not OFF (%d)", call_status);
1100                 if (!ad->calling_popup) {
1101                         ad->calling_popup = setting_create_popup(ad, ad->win_get,
1102                                                                  "IDS_ST_HEADER_UNABLE_TO_PLAY_SAMPLE_ABB",
1103                                                                  "IDS_ST_POP_SAMPLES_CANNOT_BE_PLAYED_DURING_CALLS",
1104                                                                  __calling_popup_cb, 0,
1105                                                                                                          false, false,
1106                                                                  1, "IDS_ST_BUTTON_OK");
1107                 }
1108         }
1109 }
1110
1111 #define EXP 0.001
1112
1113 static void __mm_player_msg_cb(void *user_param)
1114 {
1115         ret_if(user_param == NULL);
1116         SettingProfileUG *ad = (SettingProfileUG *)user_param;
1117
1118         SETTING_TRACE("completed_cb is called.");
1119         setting_sound_close_all_mm_players(ad);
1120 }
1121
1122 static void __mm_player_interrupted_cb(player_interrupted_code_e code, void *user_data)
1123 {
1124         ret_if(user_data == NULL);
1125         SettingProfileUG *ad = (SettingProfileUG *)user_data;
1126
1127         SETTING_TRACE("interrupted code : %d", code);
1128
1129         if (ad->mp_ringtone) {
1130                 player_state_e state;
1131                 player_get_state(*(ad->mp_ringtone), &state);
1132                 SETTING_TRACE("ringtone player state : %d", state);
1133         } else if (ad->mp_noti) {
1134                 player_state_e state;
1135                 player_get_state(*(ad->mp_noti), &state);
1136                 SETTING_TRACE("noti player state : %d", state);
1137         } else if (ad->mp_media) {
1138                 player_state_e state;
1139                 player_get_state(*(ad->mp_media), &state);
1140                 SETTING_TRACE("media player state : %d", state);
1141         }
1142 }
1143
1144 static Eina_Bool __play_timer_cb(void *data)
1145 {
1146         SETTING_TRACE_BEGIN;
1147         retv_if(!data, EINA_FALSE);
1148         SettingProfileUG *ad = (SettingProfileUG *)data;
1149
1150         if (ad->mp_prepare_async) {
1151                 SETTING_TRACE("player (%x)", ad->mp_prepare_async);
1152                 int err;
1153                 player_state_e state = -1;
1154                 err = player_get_state(*(ad->mp_prepare_async), &state);
1155                 SETTING_TRACE("state:%d", state);
1156
1157                 if (state != PLAYER_STATE_READY) {
1158                         SETTING_TRACE_ERROR("state of player is invalid %d", err);
1159                         player_unprepare(*(ad->mp_prepare_async));
1160                         player_destroy(*(ad->mp_prepare_async));
1161                         if (ad->mp_prepare_async == ad->mp_ringtone) {
1162                                 free(ad->mp_ringtone);
1163                                 ad->mp_ringtone = NULL;
1164                         } else if (ad->mp_prepare_async == ad->mp_noti) {
1165                                 free(ad->mp_noti);
1166                                 ad->mp_noti = NULL;
1167                         } else if (ad->mp_prepare_async == ad->mp_media) {
1168                                 free(ad->mp_media);
1169                                 ad->mp_media = NULL;
1170                         }
1171                         ad->mp_prepare_async = NULL;
1172                         return EINA_FALSE;
1173                 }
1174
1175                 player_set_completed_cb(*(ad->mp_prepare_async), __mm_player_msg_cb, ad);
1176                 player_set_interrupted_cb(*(ad->mp_prepare_async), __mm_player_interrupted_cb, ad);
1177
1178                 err = player_start(*(ad->mp_prepare_async));
1179                 if (err != PLAYER_ERROR_NONE) { /* if directly return error.. */
1180                         SETTING_TRACE_ERROR("player_start [%d]", err);
1181                         player_unset_completed_cb(*(ad->mp_prepare_async));
1182                         player_unset_interrupted_cb(*(ad->mp_prepare_async));
1183                         player_unprepare(*(ad->mp_prepare_async));
1184                         player_destroy(*(ad->mp_prepare_async));
1185                         if (ad->mp_prepare_async == ad->mp_ringtone) {
1186                                 free(ad->mp_ringtone);
1187                                 ad->mp_ringtone = NULL;
1188                         } else if (ad->mp_prepare_async == ad->mp_noti) {
1189                                 free(ad->mp_noti);
1190                                 ad->mp_noti = NULL;
1191                         } else if (ad->mp_prepare_async == ad->mp_media) {
1192                                 free(ad->mp_media);
1193                                 ad->mp_media = NULL;
1194                         }
1195                         ad->mp_prepare_async = NULL;
1196                 }
1197         }
1198         return EINA_FALSE;
1199 }
1200
1201 static void __mm_player_pipe_handler(void *data, void *buf, unsigned int len)
1202 {
1203         SETTING_TRACE_BEGIN;
1204 }
1205
1206 /* Async cb : to improve slider's performance when creating player */
1207 static void __mm_player_prepared_cb(void *user_data)
1208 {
1209         SETTING_TRACE_BEGIN;
1210         ret_if(!user_data);
1211         SettingProfileUG *ad = (SettingProfileUG *)user_data;
1212
1213         /* Do not call mm API in mm cb : Add timer to avoid it */
1214         /* ecore_timer_add(0.0, (Ecore_Task_Cb)__play_timer_cb, ad); */
1215         __play_timer_cb(ad);
1216
1217         /* wake main thread up for timer to work well */
1218         Ecore_Pipe *pipe;
1219         pipe = ecore_pipe_add(__mm_player_pipe_handler, NULL);
1220         ecore_pipe_write_close(pipe);
1221         ecore_pipe_del(pipe);
1222         /* end */
1223 }
1224
1225 player_h *setting_sound_play_sound(void *data, void *cb,
1226                                    char *ringtone_file,
1227                                    int vol,
1228                                    sound_type_e sound_type)
1229 {
1230         /* error check */
1231         retv_if(data == NULL, NULL);
1232         SettingProfileUG *ad = (SettingProfileUG *) data;
1233
1234         int is_existing = setting_sound_check_file_exist(ad, ringtone_file);
1235         if (is_existing == SETTING_RETURN_FAIL || NULL == ringtone_file) {
1236                 switch (sound_type) {
1237                         case SOUND_TYPE_RINGTONE:
1238                                 if (isEmulBin())
1239                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE_SDK);
1240                                 else
1241                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
1242                                 break;
1243                         case SOUND_TYPE_MEDIA:
1244                                 if (isEmulBin())
1245                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE_SDK);
1246                                 else
1247                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MEDIA_TONE);
1248                                 break;
1249                         case SOUND_TYPE_NOTIFICATION:
1250                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MSG_TONE);
1251                                 break;
1252                         default:
1253                                 if (isEmulBin())
1254                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE_SDK);
1255                                 else
1256                                         ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
1257                                 break;
1258                 }
1259
1260         } else {
1261                 if (safeStrCmp(ringtone_file, "Silent") == 0)
1262                         return NULL;
1263
1264                 ad->song_playing = (char *)g_strdup(ringtone_file);
1265         }
1266
1267         player_h *player = calloc(1, sizeof(player_h));
1268         if (!player) {
1269                 SETTING_TRACE_ERROR("failed to calloc player_h");
1270                 return NULL;
1271         }
1272
1273         int err = 0;
1274
1275         sound_manager_set_session_type(SOUND_SESSION_TYPE_MEDIA);
1276         /*sound_manager_set_media_session_option(SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START, SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY); */
1277         /*sound_manager_session_set_state_others(SOUND_STATE_PAUSE); */
1278
1279         err = player_create(player);
1280         if (err != PLAYER_ERROR_NONE) {
1281                 SETTING_TRACE_ERROR("creating the player handle failed[%d]", err);
1282                 free(player);
1283                 return NULL;
1284         }
1285
1286         err = player_set_sound_type(*player, sound_type);
1287         if (err != PLAYER_ERROR_NONE) {
1288                 SETTING_TRACE_ERROR("error to set sound_type[%d]", err);
1289                 player_destroy(*player);
1290                 free(player);
1291                 return NULL;
1292         }
1293
1294         SETTING_TRACE_DEBUG("player_set_sound_type [%d]", sound_type);
1295
1296         err = player_set_uri(*player, ad->song_playing);
1297         if (err != PLAYER_ERROR_NONE) {
1298                 SETTING_TRACE_ERROR("error to set attribute---profile_uri[%d]", err);
1299                 player_destroy(*player);
1300                 free(player);
1301                 return NULL;
1302         }
1303
1304         if (sound_type != SOUND_TYPE_MEDIA) {
1305 #if 0
1306                 /*err = player_set_session_prelistening(*player); */
1307                 /*player_prelistening_mode_e mode; */
1308
1309                 if (sound_type == SOUND_TYPE_NOTIFICATION) {
1310                         mode = PLAYER_PRELISTENING_MODE_NOTIFICATION;
1311                 } else {
1312                         mode = PLAYER_PRELISTENING_MODE_CALL;
1313                 }
1314                 err = player_set_prelistening_mode(*player, mode);
1315                 if (err != PLAYER_ERROR_NONE) {
1316                         SETTING_TRACE_ERROR("error to player_set_session_prelistening[%d]", err);
1317                         player_destroy(*player);
1318                         free(player);
1319                         return NULL;
1320                 }
1321 #endif
1322         } else {
1323 #if 0
1324                 err = player_set_safety_volume(*player);
1325                 if (err != PLAYER_ERROR_NONE) {
1326                         SETTING_TRACE_ERROR("error to player_set_volume[%d]", err);
1327                         player_destroy(*player);
1328                         free(player);
1329                         return NULL;
1330                 }
1331 #endif
1332         }
1333 #if SUPPORT_PLAYER_ASYNC
1334         err = player_prepare_async(*player, __mm_player_prepared_cb, ad);
1335         if (err != PLAYER_ERROR_NONE) {
1336                 SETTING_TRACE_ERROR("realizing the player handle failed[%d]", err);
1337                 ad->mp_prepare_async = NULL;
1338                 player_destroy(*player);
1339                 free(player);
1340                 return NULL;
1341         }
1342         ad->mp_prepare_async = player;
1343         SETTING_TRACE("waiting..player (%x)", ad->mp_prepare_async);
1344 #else
1345         err = player_prepare(*player);
1346         if (err != PLAYER_ERROR_NONE) {
1347                 SETTING_TRACE_ERROR("player_prepare() error %d", err);
1348                 player_destroy(*player);
1349                 free(player);
1350                 return NULL;
1351         }
1352
1353         player_state_e state = -1;
1354         err = player_get_state(*player, &state);
1355         SETTING_TRACE("state:%d", state);
1356         if (state != PLAYER_STATE_READY) {
1357                 SETTING_TRACE_ERROR("state of player is invalid %d", err);
1358                 player_unprepare(*player);
1359                 player_destroy(*player);
1360                 free(player);
1361                 return NULL;
1362
1363         }
1364
1365         player_set_completed_cb(*player, __mm_player_msg_cb, ad);
1366         player_set_interrupted_cb(*player, __mm_player_interrupted_cb, ad);
1367
1368         err = player_start(*player);
1369         if (err != PLAYER_ERROR_NONE) {
1370                 /* if directly return error.. */
1371                 SETTING_TRACE_ERROR("player_start [%d]", err);
1372                 player_unset_completed_cb(*player);
1373                 player_unset_interrupted_cb(*player);
1374                 player_unprepare(*player);
1375                 player_destroy(*player);
1376                 free(player);
1377                 return NULL;
1378         }
1379 #endif
1380
1381         return player;
1382 }
1383
1384 void setting_sound_play_sound_origin(player_h **mp_handle, void *data,
1385                                      void *cb, char *ringtone_file,
1386                                      /* int vol, */
1387                                      float vol,
1388                                      sound_type_e sound_type)
1389 {
1390         SETTING_TRACE_BEGIN;
1391         /* error check */
1392         ret_if(data == NULL);
1393
1394         if (vol < EXP) {
1395                 SETTING_TRACE_DEBUG("vol < EXP");
1396                 if (*mp_handle) {
1397                         if (setting_sound_stop_sound(data, *mp_handle) != SETTING_RETURN_SUCCESS) {
1398                                 /* error */
1399                         } else {
1400                                 *mp_handle = NULL;
1401                         }
1402                 }
1403                 return;
1404         }
1405
1406         int vconf_value = 0;
1407         vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TURN_OFF_ALL_SOUNDS, &vconf_value);
1408         if (vconf_value == TRUE)
1409                 return;
1410
1411         SettingProfileUG *ad = (SettingProfileUG *) data;
1412         if (*mp_handle == NULL) {
1413                 *mp_handle = setting_sound_play_sound(ad, cb, ringtone_file, vol, sound_type);
1414                 SETTING_TRACE("mp_handle (%x)", *mp_handle);
1415         }
1416 }
1417
1418 int setting_sound_stop_sound(void *data, player_h *player)
1419 {
1420         SETTING_TRACE_BEGIN;
1421         retv_if(data == NULL || player == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1422
1423         SETTING_TRACE("player (%x)", player);
1424
1425         SettingProfileUG *ad = (SettingProfileUG *) data;
1426         if (ad->song_playing) {
1427                 g_free(ad->song_playing);
1428                 ad->song_playing = NULL;
1429         }
1430
1431         player_state_e state = -1;
1432         int ret = SETTING_RETURN_SUCCESS;
1433         int prev_behavior = 0;  /*  instead of do_while(0) and break */
1434
1435         player_get_state(*player, &state);
1436         if (state == PLAYER_STATE_PLAYING) {
1437                 if (player_stop(*player) != PLAYER_ERROR_NONE) {
1438                         SETTING_TRACE("mm player stop failed");
1439                         ret = SETTING_MMPLAYER_STOP_ERR;
1440                         prev_behavior++;        /*  instead of do_while(0) and break */
1441                 }
1442         }
1443
1444         player_unset_completed_cb(*player);
1445         player_unset_interrupted_cb(*player);
1446
1447         if ((prev_behavior == 0) && (player_unprepare(*player) != PLAYER_ERROR_NONE)) {
1448                 SETTING_TRACE("mm player unrealize failed");
1449                 ret = SETTING_MMPLAYER_UNREALIZE_ERR;
1450                 prev_behavior++;        /*  instead of do_while(0) and break */
1451         }
1452
1453         if ((prev_behavior == 0) && (player_destroy(*player) != PLAYER_ERROR_NONE)) {
1454                 SETTING_TRACE("mm player destroy failed");
1455                 ret = SETTING_MMPLAYER_DESTROY_ERR;
1456         }
1457
1458         FREE(player);
1459         return ret;
1460 }
1461
1462 int __close_player(void *data, SoundType type)
1463 {
1464         SETTING_TRACE_BEGIN;
1465         /* error check */
1466         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1467
1468         SettingProfileUG *ad = (SettingProfileUG *) data;
1469         player_h *tmp = NULL;
1470
1471         switch (type) {
1472                 case SND_SLIDER_CALL:
1473                         retv_if(ad->mp_ringtone == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1474                         SETTING_TRACE("ringtone player (%x)", ad->mp_ringtone);
1475                         if (ad->mp_prepare_async == ad->mp_ringtone) {
1476                                 ad->mp_prepare_async = NULL;
1477                         }
1478                         /*player_unprepare take so much time, so if __mm_player_msg_cb was invokeing(it will trigger invoking setting_sound_stop_sound), */
1479                         /*in this time user click Back key to exit(setting_sound_deinit will trigger setting_sound_stop_sound() too) */
1480                         /*if not set ad->mp_ringtone to NULL in advance, ad->mp_ringtone will be repeatly released */
1481                         tmp = ad->mp_ringtone;
1482                         ad->mp_ringtone = NULL;
1483                         setting_sound_stop_sound(ad, tmp);
1484                         break;
1485                 case SND_SLIDER_NOTI:
1486                         retv_if(ad->mp_noti == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1487                         SETTING_TRACE("noti player (%x)", ad->mp_noti);
1488                         if (ad->mp_prepare_async == ad->mp_noti) {
1489                                 ad->mp_prepare_async = NULL;
1490                         }
1491                         tmp = ad->mp_noti;
1492                         ad->mp_noti = NULL;
1493                         setting_sound_stop_sound(ad, tmp);
1494                         break;
1495                 case SND_SLIDER_MEDIA:
1496                         retv_if(ad->mp_media == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1497                         SETTING_TRACE("media player (%x)", ad->mp_media);
1498                         if (ad->mp_prepare_async == ad->mp_media) {
1499                                 ad->mp_prepare_async = NULL;
1500                         }
1501                         tmp = ad->mp_media;
1502                         ad->mp_media = NULL;
1503                         setting_sound_stop_sound(ad, tmp);
1504                         break;
1505                 case SND_SLIDER_SYSTEM:
1506                 default:
1507                         return SETTING_RETURN_FAIL;
1508         }
1509
1510         return SETTING_RETURN_SUCCESS;
1511 }
1512
1513 int
1514 setting_sound_close_other_mm_players_but_type(void *data, sound_type_e type)
1515 {
1516         /* error check */
1517         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1518
1519         SettingProfileUG *ad = (SettingProfileUG *) data;
1520
1521         int ret = 0;
1522
1523         switch (type) {
1524                 case SOUND_TYPE_RINGTONE:       /*  close noti, media and system players */
1525                         if (__close_player(ad, SND_SLIDER_NOTI) != SETTING_RETURN_SUCCESS)
1526                                 ret++;
1527                         if (__close_player(ad, SND_SLIDER_MEDIA) != SETTING_RETURN_SUCCESS)
1528                                 ret++;
1529                         break;
1530                 case SOUND_TYPE_NOTIFICATION:   /*  close ringtone, media and system players */
1531                         if (__close_player(ad, SND_SLIDER_CALL) != SETTING_RETURN_SUCCESS)
1532                                 ret++;
1533                         if (__close_player(ad, SND_SLIDER_MEDIA) != SETTING_RETURN_SUCCESS)
1534                                 ret++;
1535                         break;
1536                 case SOUND_TYPE_MEDIA:  /*  close ringtone, noti and system players */
1537                         if (__close_player(ad, SND_SLIDER_CALL) != SETTING_RETURN_SUCCESS)
1538                                 ret++;
1539                         if (__close_player(ad, SND_SLIDER_NOTI) != SETTING_RETURN_SUCCESS)
1540                                 ret++;
1541                         break;
1542                 default:                /*  if unknown type, dont close any player */
1543                         break;
1544         }
1545
1546         SETTING_TRACE_DEBUG("ret: %d", ret);
1547
1548         if (ret == 0)
1549                 return SETTING_RETURN_SUCCESS;
1550         else
1551                 return SETTING_RETURN_FAIL;
1552 }
1553
1554
1555 int setting_sound_close_all_mm_players(void *data)
1556 {
1557         /* error check */
1558         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1559
1560         SettingProfileUG *ad = (SettingProfileUG *) data;
1561
1562         int ret = 0;
1563
1564         if (__close_player(ad, SND_SLIDER_CALL) != SETTING_RETURN_SUCCESS)
1565                 ret++;
1566         if (__close_player(ad, SND_SLIDER_NOTI) != SETTING_RETURN_SUCCESS)
1567                 ret++;
1568         if (__close_player(ad, SND_SLIDER_MEDIA) != SETTING_RETURN_SUCCESS)
1569                 ret++;
1570
1571         if (ret == 0)
1572                 return SETTING_RETURN_SUCCESS;
1573         else
1574                 return SETTING_RETURN_FAIL;
1575 }