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