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