setting-profile/src/setting-profile.c

   1 /*
   2  * setting
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://floralicense.org/license/
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <setting-profile.h>
  19 #include <haptic.h>
  20 #include <utilX.h>
  21 #include <Ecore_X.h>
  22
  23 #ifndef UG_MODULE_API
  24 #define UG_MODULE_API __attribute__ ((visibility("default")))
  25 #endif
  26
  27 SettingProfileUG *g_ProfileUG = NULL;   /*  just a handler */
  28
  29 extern char *repeat_type[];
  30
  31 static void setting_profile_ug_cb_resize(void *data, Evas *e,
  32                                          Evas_Object *obj, void *event_info)
  33 {
  34         ret_if(data == NULL);
  35
  36         SettingProfileUG *ad = (SettingProfileUG *) data;
  37         setting_view_update(&setting_view_profile_sound_main, ad);
  38
  39 }
  40
  41 /**
  42  *@ To sync Setting App volume with Volume Hard key volume
  43  */
  44
  45 void __sound_volume_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
  46 {
  47         SETTING_TRACE_BEGIN;
  48         ret_if(!user_data);
  49         SettingProfileUG *ad = user_data;
  50         Setting_GenGroupItem_Data *item_data = NULL;
  51
  52         Evas_Object *slider = NULL;
  53         switch (type)
  54         {
  55                 case SOUND_TYPE_SYSTEM:
  56                         SETTING_TRACE_DEBUG("system");
  57                         if (ad->data_touch_volume)
  58                                 item_data = ad->data_touch_volume;
  59                                 //slider = ad->data_touch_volume->eo_check;
  60                         break;
  61                 case SOUND_TYPE_NOTIFICATION:
  62                         SETTING_TRACE_DEBUG("notification");
  63                         if (ad->data_noti_volume)
  64                                 item_data = ad->data_noti_volume;
  65                                 //slider = ad->data_noti_volume->eo_check;
  66                         break;
  67                 case SOUND_TYPE_RINGTONE:
  68                         SETTING_TRACE_DEBUG("ringtone");
  69                         if (ad->data_call_volume)
  70                                 item_data = ad->data_call_volume;
  71                                 //slider = ad->data_call_volume->eo_check;
  72                         break;
  73                 case SOUND_TYPE_MEDIA:
  74                         SETTING_TRACE_DEBUG("media");
  75                         if (ad->data_media_volume)
  76                                 item_data = ad->data_media_volume;
  77                                 //slider = ad->data_media_volume->eo_check;
  78                         break;
  79                 //At present, there are only 4 types supported:RINGTONE,NOTIFICATION,SYSTEM,MEDIA
  80                 default:
  81                         SETTING_TRACE_ERROR("Invalid sound type:%d", type);
  82                         return;
  83         }
  84
  85         if (item_data && item_data->eo_check)
  86         {
  87                 SETTING_TRACE_DEBUG("update slider value");
  88                 int volume = 0;
  89                 double old_volume = 0;
  90                 sound_manager_get_volume(type, &volume);        /* system */
  91                 SETTING_TRACE_DEBUG("get_volume is %d", volume);
  92
  93                 old_volume = elm_slider_value_get(item_data->eo_check);
  94                 SETTING_TRACE_DEBUG("slider volume is %d", old_volume);
  95                 if ((int)volume != (int)(old_volume + 0.5)) {   /* reset again */
  96                         elm_slider_value_set(item_data->eo_check, (double)volume);
  97                         SETTING_TRACE_DEBUG("update to new value %d", volume);
  98                         item_data->chk_status = volume;
  99                         elm_genlist_item_update(item_data->item);
 100                 }
 101         }
 102 }
 103
 104 #if DISABLED_CODE
 105 static char* __gl_sound_slider_text_get(void *data, Evas_Object *obj, const char *part)
 106 {
 107         retv_if(data == NULL, NULL);
 108         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data*)data;
 109
 110         if(item_data->keyStr)
 111                 return (char*)g_strdup(_(item_data->keyStr));
 112         else
 113                 return NULL;
 114 }
 115 #endif
 116 static Evas_Object* __gl_sound_slider_content_get(void *data, Evas_Object *obj, const char *part)
 117 {
 118         //appcore_measure_start();
 119         retv_if(data == NULL, NULL);
 120         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data*)data;
 121         Evas_Object *slider = setting_create_slider(obj, item_data->evas,
 122                                                 item_data->l_swallow_path,
 123                                                 item_data->r_swallow_path,
 124                                                 item_data->chk_status,
 125                                                 item_data->isIndicatorVisible,
 126                                                 item_data->slider_min,
 127                                                 item_data->slider_max,
 128                                                 item_data->chk_change_cb,
 129                                                 item_data->start_change_cb,
 130                                                 item_data->stop_change_cb,
 131                                                 item_data);
 132
 133         if(slider == NULL)
 134                 return NULL;
 135
 136         item_data->eo_check = slider;
 137
 138         evas_object_pass_events_set(slider, EINA_TRUE);
 139         evas_object_propagate_events_set(slider, EINA_FALSE);
 140
 141         if(item_data->userdata == NULL)
 142                 return NULL;
 143
 144         SettingProfileUG *ad = (SettingProfileUG*)item_data->userdata;
 145
 146         if((item_data->belongs_to == SETTING_VOL_SOUND_GROUP)
 147                         && (ad->data_sound)
 148                         && (ad->data_sound->chk_status == FALSE))
 149                 setting_disable_genlist_item(item_data->item);
 150         else if((item_data->belongs_to == SETTING_VOL_VIBRATION_GROUP)
 151                         && (ad->data_vibration)
 152                         && (ad->data_vibration->chk_status == FALSE))
 153                 setting_disable_genlist_item(item_data->item);
 154
 155         return slider;
 156 }
 157
 158 static void __gl_sound_slider_del(void *data, Evas_Object *obj)
 159 {
 160         Setting_GenGroupItem_Data *item_data =
 161             (Setting_GenGroupItem_Data *) data;
 162         if (item_data) {
 163                 G_FREE(item_data->keyStr);
 164                 G_FREE(item_data->sub_desc);
 165                 G_FREE((item_data->l_swallow_path));
 166                 G_FREE((item_data->r_swallow_path));
 167                 G_FREE(item_data->item_style);
 168
 169
 170                 if (item_data->digits_filter_data)
 171                 {
 172                         G_FREE(item_data->digits_filter_data->accepted);
 173                         G_FREE(item_data->digits_filter_data->rejected);
 174                         FREE(item_data->digits_filter_data);
 175
 176                 }
 177
 178                 if (item_data->notify) {
 179                         evas_object_del(item_data->notify);
 180                         item_data->notify = NULL;
 181                 }
 182
 183                 FREE(item_data->limit_filter_data);
 184                 FREE(item_data);
 185         }
 186         return;
 187 }
 188
 189 static void setting_profile_vconf_change_cb(keynode_t *key, void *data)
 190 {
 191         ret_if(data == NULL);
 192
 193         SettingProfileUG *ad = data;
 194         int status = 0;
 195         int ret = 0;
 196         char *pa_ringtone = NULL;
 197         char *sub_desc = NULL;
 198         char *vconf_name = vconf_keynode_get_name(key);
 199
 200         if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
 201                 status = vconf_keynode_get_int(key);
 202                 SETTING_TRACE("status:%d", status);
 203                 if (VCONFKEY_SYSMAN_MMC_MOUNTED != status) {
 204                         ret_if((!ad->mp_ringtone && !ad->mp_noti && !ad->mp_media && !ad->mp_sys));
 205                         SETTING_TRACE("song_playing:%s", ad->song_playing);
 206
 207                         if (!safeStrNCmp(SETTING_PROFILE_MMC_PATH, ad->song_playing,
 208                              safeStrLen(SETTING_PROFILE_MMC_PATH))) {
 209                                 /*  close mm plaer */
 210                                 setting_profile_close_all_mm_players(ad);
 211                                 /*  close vibration */
 212                         #if MIGRATION_HAPTIC
 213                                 if (haptic_stop_all_effects(ad->hnd_hpt) != 0) {
 214                                         SETTING_TRACE("ERROR haptic_stop_all_effects");
 215                                 }
 216                         #endif
 217                         }
 218                         /* when remove mmc card, change default tone */
 219                         char *call_tone = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 220                         if(call_tone && !safeStrNCmp(SETTING_PROFILE_MMC_PATH, call_tone, safeStrLen(SETTING_PROFILE_MMC_PATH)))
 221                         {
 222                                 ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, SETTING_DEFAULT_CALL_TONE);
 223                                 if(ret < 0)
 224                                         SETTING_TRACE_DEBUG("failed to set vconf");
 225                         }
 226                 }
 227         }
 228         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_SOUND_STATUS_BOOL)) {
 229                 status = vconf_keynode_get_bool(key);
 230                 SETTING_TRACE_DEBUG("sound status is changed. %d", status);
 231                 elm_check_state_set(ad->data_sound->eo_check, status);
 232                 if(status)
 233                 {
 234                         setting_enable_genlist_item(ad->data_call_volume->item);
 235                         setting_enable_genlist_item(ad->data_noti_volume->item);
 236                         setting_enable_genlist_item(ad->data_media_volume->item);
 237                         setting_enable_genlist_item(ad->data_touch_volume->item);
 238                 }
 239                 else
 240                 {
 241                         setting_disable_genlist_item(ad->data_call_volume->item);
 242                         setting_disable_genlist_item(ad->data_noti_volume->item);
 243                         setting_disable_genlist_item(ad->data_media_volume->item);
 244                         setting_disable_genlist_item(ad->data_touch_volume->item);
 245                 }
 246         }
 247         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL)) {
 248                 status = vconf_keynode_get_bool(key);
 249                 SETTING_TRACE_DEBUG("vibration status is changed. %d", status);
 250                 elm_check_state_set(ad->data_vibration->eo_check, status);
 251                 if(status)
 252                 {
 253                         setting_enable_genlist_item(ad->data_vib_volume->item);
 254                         setting_enable_genlist_item(ad->data_touch_vib->item);
 255                 }
 256                 else
 257                 {
 258                         setting_disable_genlist_item(ad->data_vib_volume->item);
 259                         setting_disable_genlist_item(ad->data_touch_vib->item);
 260                 }
 261         }
 262         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR)) {
 263                 pa_ringtone = (char *)g_strdup(vconf_keynode_get_str(key));
 264                 if(setting_profile_check_file_exist(ad, pa_ringtone) == SETTING_RETURN_FAIL)
 265                 {
 266                         G_FREE(pa_ringtone);
 267                         pa_ringtone = (char *)strdup(SETTING_DEFAULT_CALL_TONE);
 268                         ret = vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, pa_ringtone);
 269                         if(ret < 0)
 270                                 SETTING_TRACE_DEBUG("failed to set vconf");
 271                 }
 272                 sub_desc = setting_file_basename(pa_ringtone);
 273                 if(ad->data_call_alert_tone)
 274                 {
 275                         ad->data_call_alert_tone->sub_desc = (char*)g_strdup(sub_desc);
 276                         elm_genlist_item_update(ad->data_call_alert_tone->item);
 277                 }
 278                 G_FREE(pa_ringtone);
 279                 G_FREE(sub_desc);
 280         }
 281         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR)) {
 282                 pa_ringtone = (char *)g_strdup(vconf_keynode_get_str(key));
 283                 if(setting_profile_check_file_exist(ad, pa_ringtone) == SETTING_RETURN_FAIL)
 284                 {
 285                         G_FREE(pa_ringtone);
 286                         pa_ringtone = (char *)g_strdup(SETTING_DEFAULT_MSG_TONE);
 287                         ret = vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, pa_ringtone);
 288                         if(ret < 0)
 289                                 SETTING_TRACE_DEBUG("failed to set vconf");
 290                 }
 291                 sub_desc = setting_file_basename(pa_ringtone);
 292                 if(ad->data_msg_alert_tone)
 293                 {
 294                         ad->data_msg_alert_tone->sub_desc = (char*)g_strdup(sub_desc);
 295                         elm_genlist_item_update(ad->data_msg_alert_tone->item);
 296                 }
 297                 G_FREE(pa_ringtone);
 298                 G_FREE(sub_desc);
 299         }
 300         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT)) {
 301                 status = vconf_keynode_get_int(key);
 302
 303                 if(status >= 0 && ad->data_msg_alert_repeat)
 304                 {
 305                         ad->data_msg_alert_repeat->sub_desc = (char*)g_strdup(_(repeat_type[status]));
 306                         elm_genlist_item_update(ad->data_msg_alert_repeat->item);
 307                 }
 308         }
 309         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR)) {
 310                 pa_ringtone = (char *)g_strdup(vconf_keynode_get_str(key));
 311                 if(setting_profile_check_file_exist(ad, pa_ringtone) == SETTING_RETURN_FAIL)
 312                 {
 313                         G_FREE(pa_ringtone);
 314                         pa_ringtone = (char *)g_strdup(SETTING_DEFAULT_EMAIL_TONE);
 315                         ret = vconf_set_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, pa_ringtone);
 316                         if(ret < 0)
 317                                 SETTING_TRACE_DEBUG("failed to set vconf");
 318                 }
 319                 sub_desc = setting_file_basename(pa_ringtone);
 320                 if(ad->data_email_alert_tone)
 321                 {
 322                         ad->data_email_alert_tone->sub_desc = (char*)g_strdup(sub_desc);
 323                         elm_genlist_item_update(ad->data_email_alert_tone->item);
 324                 }
 325                 G_FREE(pa_ringtone);
 326                 G_FREE(sub_desc);
 327         }
 328         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT)) {
 329                 status = vconf_keynode_get_int(key);
 330
 331                 if(status >= 0 && ad->data_email_alert_repeat)
 332                 {
 333                         ad->data_email_alert_repeat->sub_desc = (char*)g_strdup(_(repeat_type[status]));
 334                         elm_genlist_item_update(ad->data_email_alert_repeat->item);
 335                 }
 336         }
 337 }
 338
 339 int setting_profile_listen_vconf_change(void *data)
 340 {
 341         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 342
 343         int ret = 0;
 344
 345         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 346                                                                 setting_profile_vconf_change_cb, data);
 347         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 348                                         (char *)VCONFKEY_SYSMAN_MMC_STATUS, ret);
 349
 350         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL,
 351                                                                         setting_profile_vconf_change_cb, data);
 352         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 353                                         (char *)VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, ret);
 354
 355         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL,
 356                                                                         setting_profile_vconf_change_cb, data);
 357         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 358                                         (char *)VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, ret);
 359
 360         /* add ringtone tab's vconfkeys */
 361         // incoming call ringtone.
 362         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR,
 363                                                                         setting_profile_vconf_change_cb, data);
 364         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 365                                         (char *)VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, ret);
 366         // message alert tone
 367         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR,
 368                                                                         setting_profile_vconf_change_cb, data);
 369         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 370                                         (char *)VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, ret);
 371         // message alert repitition.
 372         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT,
 373                                                                         setting_profile_vconf_change_cb, data);
 374         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 375                                         (char *)VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, ret);
 376         // email alert tone.
 377         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR,
 378                                                                         setting_profile_vconf_change_cb, data);
 379         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 380                                         (char *)VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, ret);
 381         // email_alert_repitition
 382         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT,
 383                                                                         setting_profile_vconf_change_cb, data);
 384         setting_retvm_if(ret < 0, ret, "%s notifications Failed(%d)",
 385                                         (char *)VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, ret);
 386
 387         return 0;
 388 }
 389
 390 int setting_profile_unlisten_vconf_change(void *data)
 391 {
 392         /* unused listen */
 393         (void)vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 394                                                                 setting_profile_vconf_change_cb);
 395         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL,
 396                                                                 setting_profile_vconf_change_cb);
 397         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL,
 398                                                                 setting_profile_vconf_change_cb);
 399
 400         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR,
 401                                                                         setting_profile_vconf_change_cb);
 402         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR,
 403                                                                         setting_profile_vconf_change_cb);
 404         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT,
 405                                                                         setting_profile_vconf_change_cb);
 406         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR,
 407                                                                         setting_profile_vconf_change_cb);
 408         (void)vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT,
 409                                                                         setting_profile_vconf_change_cb);
 410
 411         return 0;
 412 }
 413
 414 void __setting_profile_ug_key_grab(SettingProfileUG *ad)
 415 {
 416         SETTING_TRACE_BEGIN;
 417         Ecore_X_Window xwin = 0;
 418         Ecore_X_Display *disp = NULL;
 419
 420         int ret = 0;
 421
 422         if(ad == NULL)
 423                 return;
 424
 425         disp = ecore_x_display_get();
 426         xwin = elm_win_xwindow_get((Evas_Object*)ug_get_window());
 427
 428         ret = utilx_grab_key(disp, xwin, KEY_VOLUMEUP, TOP_POSITION_GRAB);
 429         if(ret)
 430                 return;
 431         ret = utilx_grab_key(disp, xwin, KEY_VOLUMEDOWN, TOP_POSITION_GRAB);
 432         if(ret)
 433                 return;
 434
 435         ad->event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, NULL, NULL);
 436         SETTING_TRACE_END;
 437 }
 438 void __setting_profile_ug_key_ungrab(SettingProfileUG *ad)
 439 {
 440         SETTING_TRACE_BEGIN;
 441         Ecore_X_Window xwin = 0;
 442         Ecore_X_Display *disp = NULL;
 443
 444         int ret = 0;
 445
 446         if(ad == NULL)
 447                 return;
 448
 449         disp = ecore_x_display_get();
 450         xwin = elm_win_xwindow_get((Evas_Object*)ug_get_window());
 451
 452         ret = utilx_ungrab_key(disp, xwin, KEY_VOLUMEUP);
 453         if(ret)
 454                 return;
 455         ret = utilx_ungrab_key(disp, xwin, KEY_VOLUMEDOWN);
 456         if(ret)
 457                 return;
 458
 459         ecore_event_handler_del(ad->event_handler);
 460 }
 461
 462 static void *setting_profile_ug_on_create(ui_gadget_h ug,
 463                                           enum ug_mode mode, service_h service,
 464                                           void *priv)
 465 {
 466         SETTING_TRACE_BEGIN;
 467         //appcore_measure_start();
 468         retv_if(priv == NULL, NULL);
 469
 470         SettingProfileUG *profileUG = priv;
 471         profileUG->ug = ug;
 472         g_ProfileUG = profileUG;
 473
 474         profileUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 475         profileUG->win_get = (Evas_Object *) ug_get_window();
 476
 477         evas_object_show(profileUG->win_main_layout);
 478         profileUG->evas = evas_object_evas_get(profileUG->win_main_layout);
 479
 480         setting_retvm_if(profileUG->win_main_layout == NULL, NULL, "cannot get main window ");
 481
 482         //At present, there are only 4 types supported:RINGTONE,NOTIFICATION,SYSTEM,MEDIA
 483         sound_manager_set_volume_changed_cb(__sound_volume_changed_cb, profileUG);
 484
 485         setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 486
 487         /* register view node table */
 488         setting_view_node_table_intialize();
 489         setting_view_node_table_register(&setting_view_profile_sound_main, NULL);
 490
 491         setting_create_Gendial_itc("dialogue/1text.1icon", &(profileUG->itc_1text_1icon));
 492         setting_create_Gendial_itc("dialogue/title", &(profileUG->itc_group_item));
 493         setting_create_Gendial_itc("dialogue/2text.3", &(profileUG->itc_2text_2));
 494         profileUG->itc_layout.item_style = "dialogue/1icon";
 495         profileUG->itc_layout.func.text_get = NULL; //__gl_sound_slider_text_get;
 496         profileUG->itc_layout.func.content_get = __gl_sound_slider_content_get;
 497         profileUG->itc_layout.func.state_get = NULL;
 498         profileUG->itc_layout.func.del = __gl_sound_slider_del;
 499
 500         setting_create_Gendial_itc("dialogue/2text.3/expandable", &(profileUG->itc_2text_3_parent));
 501         setting_create_Gendial_itc("dialogue/1text.1icon/expandable2", &(profileUG->itc_1icon_1text_sub));
 502         setting_create_Gendial_itc("multiline/1text", &(profileUG->itc_bg_1icon));
 503
 504         profileUG->itc_seperator.item_style = "dialogue/separator";
 505         profileUG->itc_seperator.func.text_get = NULL;
 506         profileUG->itc_seperator.func.content_get = NULL;
 507         profileUG->itc_seperator.func.state_get = NULL;
 508         profileUG->itc_seperator.func.del = NULL;
 509
 510         /*  creating a view. */
 511         setting_view_node_set_cur_view(&setting_view_profile_sound_main);
 512         setting_view_create(&setting_view_profile_sound_main, (void *)profileUG);
 513
 514         evas_object_event_callback_add(profileUG->win_main_layout,
 515                                        EVAS_CALLBACK_RESIZE,
 516                                        setting_profile_ug_cb_resize, profileUG);
 517
 518         setting_profile_listen_vconf_change(profileUG);
 519
 520         return profileUG->ly_main;
 521 }
 522
 523 static void setting_profile_ug_on_start(ui_gadget_h ug, service_h service, void *priv)
 524 {
 525 }
 526
 527 static void setting_profile_ug_on_pause(ui_gadget_h ug, service_h service, void *priv)
 528 {
 529         ret_if(priv == NULL);
 530         SettingProfileUG *profileUG = (SettingProfileUG*)priv;
 531
 532         /* if click home key, players have to be closed */
 533         setting_profile_close_all_mm_players(profileUG);
 534 }
 535
 536 static void setting_profile_ug_on_resume(ui_gadget_h ug, service_h service, void *priv)
 537 {
 538         ret_if(priv == NULL);
 539         SettingProfileUG *profileUG = (SettingProfileUG *)priv;
 540
 541         /* update path of tones */
 542         char *pa_tone_path = NULL;
 543
 544         if(profileUG->data_call_volume)
 545         {
 546                 int volume;
 547                 SETTING_TRACE_DEBUG("ringtone volume %x", profileUG->data_call_volume);
 548                 sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume); /* system */
 549                 SETTING_TRACE_DEBUG("get_volume is %d", volume);
 550                 elm_slider_value_set(profileUG->data_call_volume->eo_check, (double)volume);
 551                 SETTING_TRACE_DEBUG("update to new value %d", volume);
 552         }
 553         if(profileUG->data_noti_volume)
 554         {
 555                 int volume;
 556                 SETTING_TRACE_DEBUG("noti volume %x", profileUG->data_noti_volume);
 557                 sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &volume);     /* system */
 558                 SETTING_TRACE_DEBUG("get_volume is %d", volume);
 559                 elm_slider_value_set(profileUG->data_noti_volume->eo_check, (double)volume);
 560                 SETTING_TRACE_DEBUG("update to new value %d", volume);
 561         }
 562         if(profileUG->data_media_volume)
 563         {
 564                 int volume;
 565                 SETTING_TRACE_DEBUG("media volume %x", profileUG->data_media_volume);
 566                 sound_manager_get_volume(SOUND_TYPE_MEDIA, &volume);    /* system */
 567                 SETTING_TRACE_DEBUG("get_volume is %d", volume);
 568                 elm_slider_value_set(profileUG->data_media_volume->eo_check, (double)volume);
 569                 SETTING_TRACE_DEBUG("update to new value %d", volume);
 570         }
 571         if(profileUG->data_touch_volume)
 572         {
 573                 int volume;
 574                 SETTING_TRACE_DEBUG("system volume %x", profileUG->data_touch_volume);
 575                 sound_manager_get_volume(SOUND_TYPE_SYSTEM, &volume);   /* system */
 576                 SETTING_TRACE_DEBUG("get_volume is %d", volume);
 577                 elm_slider_value_set(profileUG->data_touch_volume->eo_check, (double)volume);
 578                 SETTING_TRACE_DEBUG("update to new value %d", volume);
 579         }
 580
 581         /* 1. incoming call ringtone */
 582         if(profileUG->data_call_alert_tone)
 583         {
 584                 SETTING_TRACE_DEBUG("change call_alert_tone %x", profileUG->data_call_alert_tone);
 585                 pa_tone_path = vconf_get_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR);
 586                 if((pa_tone_path == NULL) || (setting_profile_check_file_exist(profileUG, pa_tone_path) == SETTING_RETURN_FAIL))
 587                 {
 588                         pa_tone_path = (char *)strdup(SETTING_DEFAULT_CALL_TONE);
 589                         if(vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, pa_tone_path) < 0)
 590                                 return;
 591                         profileUG->data_call_alert_tone->sub_desc = setting_file_basename(pa_tone_path);
 592                         elm_genlist_item_update(profileUG->data_call_alert_tone->item);
 593                 }
 594
 595                 FREE(pa_tone_path);
 596         }
 597
 598         /* 2. message ringtone */
 599         if(profileUG->data_msg_alert_tone)
 600         {
 601                 SETTING_TRACE_DEBUG("change msg_alert_tone %x", profileUG->data_msg_alert_tone);
 602                 pa_tone_path = vconf_get_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR);
 603                 if((pa_tone_path == NULL) || (setting_profile_check_file_exist(profileUG, pa_tone_path) == SETTING_RETURN_FAIL))
 604                 {
 605                         pa_tone_path = (char *)strdup(SETTING_DEFAULT_MSG_TONE);
 606                         if(vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, SETTING_DEFAULT_MSG_TONE) < 0) {
 607                                 FREE(pa_tone_path);
 608                                 return;
 609                         }
 610
 611                         profileUG->data_msg_alert_tone->sub_desc = setting_file_basename(pa_tone_path);
 612                         elm_genlist_item_update(profileUG->data_msg_alert_tone->item);
 613                 }
 614
 615                 FREE(pa_tone_path);
 616
 617         }
 618
 619         /* 3. email ringtone */
 620         if(profileUG->data_email_alert_tone)
 621         {
 622                 SETTING_TRACE_DEBUG("change email_alert_tone %x", profileUG->data_email_alert_tone);
 623                 pa_tone_path = vconf_get_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR);
 624                 if((pa_tone_path == NULL) || (setting_profile_check_file_exist(profileUG, pa_tone_path) == SETTING_RETURN_FAIL))
 625                 {
 626                         pa_tone_path = (char *)strdup(SETTING_DEFAULT_MSG_TONE);
 627                         if(vconf_set_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, SETTING_DEFAULT_MSG_TONE) < 0) {
 628                                 FREE(pa_tone_path);
 629                                 return;
 630                         }
 631                         profileUG->data_email_alert_tone->sub_desc = setting_file_basename(pa_tone_path);
 632                         elm_genlist_item_update(profileUG->data_email_alert_tone->item);
 633                 }
 634
 635                 FREE(pa_tone_path);
 636
 637         }
 638 }
 639
 640 static void setting_profile_ug_on_destroy(ui_gadget_h ug, service_h service, void *priv)
 641 {
 642         ret_if(priv == NULL);
 643
 644         SettingProfileUG *profileUG = priv;
 645
 646         setting_profile_unlisten_vconf_change(profileUG);
 647         evas_object_event_callback_del(profileUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_profile_ug_cb_resize); /* fix flash issue for gallery */
 648         profileUG->ug = ug;
 649
 650         //At present, there are only 4 types supported:RINGTONE,NOTIFICATION,SYSTEM,MEDIA
 651         sound_manager_unset_volume_changed_cb();
 652
 653
 654         int ret = haptic_close(profileUG->hnd_hpt);
 655         if (ret != 0) {
 656                 SETTING_TRACE_DEBUG("%s*** [ERR] Failed haptic_deinitialize ***%s",
 657                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
 658         }
 659         setting_profile_close_all_mm_players(profileUG);
 660
 661         /* it is the view manage strategy to invoke view's destory operation. */
 662         setting_view_destroy(&setting_view_profile_sound_main, profileUG);
 663         if (NULL != ug_get_layout(profileUG->ug)) {
 664                 evas_object_hide((Evas_Object *) ug_get_layout(profileUG->ug));
 665                 evas_object_del((Evas_Object *) ug_get_layout(profileUG->ug));
 666         }
 667 }
 668
 669 static void setting_profile_ug_on_message(ui_gadget_h ug, service_h msg,
 670                                           service_h service, void *priv)
 671 {
 672
 673 }
 674
 675 static void setting_profile_ug_on_event(ui_gadget_h ug,
 676                                         enum ug_event event, service_h service, void *priv)
 677 {
 678         SETTING_TRACE_BEGIN;
 679         SettingProfileUG *ad = (SettingProfileUG *)priv;
 680
 681         switch (event) {
 682                 case UG_EVENT_LOW_MEMORY:
 683                         break;
 684                 case UG_EVENT_LOW_BATTERY:
 685                         break;
 686                 case UG_EVENT_LANG_CHANGE:
 687                         break;
 688                 case UG_EVENT_ROTATE_PORTRAIT:
 689                         break;
 690                 case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 691                         break;
 692                 case UG_EVENT_ROTATE_LANDSCAPE:
 693                         break;
 694                 case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 695                         break;
 696                 case UG_EVENT_REGION_CHANGE:
 697                         break;
 698                 default:
 699                         break;
 700         }
 701 }
 702
 703 static void setting_profile_ug_on_key_event(ui_gadget_h ug,
 704                                             enum ug_key_event event, service_h service, void *priv)
 705 {
 706         ret_if(priv == NULL);
 707
 708         SettingProfileUG *ad = (SettingProfileUG *) priv;
 709
 710         switch (event) {
 711                 case UG_KEY_EVENT_END:
 712                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 713                             elm_naviframe_bottom_item_get(ad->navi_bar)) {
 714                                 ug_destroy_me(ug);
 715                         } else {
 716                                 if (&setting_view_profile_sound_main ==
 717                                     setting_view_node_get_cur_view()) {
 718
 719                                         /* close mm plaer */
 720                                         setting_profile_close_all_mm_players(ad);
 721                                         /* close vibration */
 722                                 #if MIGRATION_HAPTIC
 723                                         if (haptic_stop_all_effects(ad->hnd_hpt) != 0) {
 724                                                 SETTING_TRACE("ERROR haptic_stop_all_effects");
 725                                         }
 726                                 #endif
 727                                 }
 728                                 setting_view_cb_at_endKey(ad);
 729                         }
 730                         break;
 731                 default:
 732                         break;
 733         }
 734 }
 735
 736 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 737 {
 738         SETTING_TRACE_BEGIN;
 739         //appcore_measure_start();
 740         SettingProfileUG *profileUG = calloc(1, sizeof(SettingProfileUG));
 741         setting_retvm_if(!profileUG, -1, "Create SettingProfileUG obj failed");
 742
 743         ops->create = setting_profile_ug_on_create;
 744         ops->start = setting_profile_ug_on_start;
 745         ops->pause = setting_profile_ug_on_pause;
 746         ops->resume = setting_profile_ug_on_resume;
 747         ops->destroy = setting_profile_ug_on_destroy;
 748         ops->message = setting_profile_ug_on_message;
 749         ops->event = setting_profile_ug_on_event;
 750         ops->key_event = setting_profile_ug_on_key_event;
 751         ops->priv = profileUG;
 752         ops->opt = UG_OPT_INDICATOR_ENABLE;
 753         /* Haptic init */
 754         SETTING_TRACE("before haptic initilization");
 755         int haptic_return = 0;
 756         haptic_return = haptic_open(HAPTIC_DEVICE_0, &(profileUG->hnd_hpt));
 757         SETTING_TRACE("profileUG->hnd_hpt : %d", profileUG->hnd_hpt);
 758         if (haptic_return < 0) {
 759                 SETTING_TRACE_DEBUG("%s*** [ERR] Failed haptic_open ***%s",
 760                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
 761         }
 762
 763         return 0;
 764 }
 765
 766 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 767 {
 768         ret_if(ops == NULL);
 769
 770         struct SettingProfileUG *profileUG;
 771         profileUG = ops->priv;
 772         if (profileUG)
 773                 FREE(profileUG);
 774 }
 775
 776 /* ***************************************************
 777  *
 778  *general func
 779  *
 780  ***************************************************/
 781
 782 int setting_profile_check_file_exist(void *data, const char *file_path)
 783 {
 784         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 785         retv_if(file_path == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 786
 787         if (!ecore_file_exists(file_path)) {
 788                 SETTING_TRACE_ERROR("Cannot find the ringtone file[%s]!", file_path);
 789                 return SETTING_RETURN_FAIL;
 790         }
 791
 792         int mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
 793         vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_status);
 794         if (VCONFKEY_SYSMAN_MMC_MOUNTED != mmc_status)
 795         {
 796                 if (!safeStrNCmp(SETTING_PROFILE_MMC_PATH, file_path, safeStrLen(SETTING_PROFILE_MMC_PATH)))
 797                 {
 798                         return SETTING_RETURN_FAIL;
 799                 }
 800         }
 801         return SETTING_RETURN_SUCCESS;
 802 }
 803
 804 player_h *setting_profile_play_sound(void *data, void *cb,
 805                                  char *ringtone_file,
 806                                  int vol,
 807                                  sound_type_e sound_type)
 808 {
 809         /* error check */
 810         retv_if(data == NULL, NULL);
 811
 812         SettingProfileUG *ad = (SettingProfileUG *) data;
 813
 814         int is_existing = setting_profile_check_file_exist(ad, ringtone_file);
 815         if(is_existing == SETTING_RETURN_FAIL || NULL == ringtone_file)
 816         {
 817                 char pattern_file[MAX_COMMON_BUFFER_LEN] = {0,};
 818                 switch(sound_type)
 819                 {
 820                         case SOUND_TYPE_RINGTONE:
 821                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
 822                                 break;
 823                         case SOUND_TYPE_MEDIA:
 824                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MEDIA_TONE);
 825                                 break;
 826                         case SOUND_TYPE_NOTIFICATION:
 827                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MSG_TONE);
 828                                 break;
 829                         case SOUND_TYPE_SYSTEM:
 830                                 svi_get_path(SVI_TYPE_SND, SVI_SND_TOUCH_TOUCH1, pattern_file, sizeof(pattern_file));
 831                                 retv_if(pattern_file == NULL, NULL);
 832                                 ad->song_playing = (char *)g_strdup(pattern_file);
 833                                 break;
 834                         default:
 835                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
 836                                 break;
 837                 }
 838
 839         }
 840         else {
 841                 ad->song_playing = (char *)g_strdup(ringtone_file);
 842         }
 843
 844         player_h *player = calloc(1, sizeof(player_h));
 845         if (!player) {
 846                 SETTING_TRACE_ERROR("failed to calloc player_h");
 847                 return NULL;
 848         }
 849
 850         int err = 0;
 851
 852         err = player_create(player);
 853         if (err != PLAYER_ERROR_NONE) {
 854                 SETTING_TRACE_ERROR("creating the player handle failed[%d]", err);
 855                 free(player);
 856                 return NULL;
 857         }
 858
 859         err = player_set_sound_type(*player, sound_type);
 860         if (err != PLAYER_ERROR_NONE) {
 861                 SETTING_TRACE_ERROR("error to set sound_type[%d]", err);
 862                 player_destroy(*player);
 863                 free(player);
 864                 return NULL;
 865         }
 866         SETTING_TRACE_DEBUG("player_set_sound_type [%d]", sound_type);
 867
 868         err = player_set_uri(*player, ad->song_playing);
 869         if (err != PLAYER_ERROR_NONE) {
 870                 SETTING_TRACE_ERROR("error to set attribute---profile_uri[%d]", err);
 871                 player_destroy(*player);
 872                 free(player);
 873                 return NULL;
 874         }
 875
 876         err = player_prepare(*player);
 877         if (err != PLAYER_ERROR_NONE) {
 878                 SETTING_TRACE_ERROR("realizing the player handle failed[%d]", err);
 879                 player_destroy(*player);
 880                 free(player);
 881                 return NULL;
 882         }
 883
 884         player_state_e state = -1;
 885         player_get_state(*player, &state);
 886         SETTING_TRACE("state:%d", state);
 887
 888         if (state != PLAYER_STATE_READY) {
 889                 SETTING_TRACE_ERROR("state of player is invalid %d", err);
 890                 player_unprepare(*player);
 891                 player_destroy(*player);
 892                 free(player);
 893                 return NULL;
 894         }
 895
 896         player_set_completed_cb(*player, cb, ad);
 897         err = player_start(*player);
 898         if (err != PLAYER_ERROR_NONE) { /* if directly return error.. */
 899                 SETTING_TRACE_ERROR("player_start [%d]", err);
 900                 player_unset_completed_cb(*player);
 901                 player_unprepare(*player);
 902                 player_destroy(*player);
 903                 free(player);
 904                 return NULL;
 905         }
 906
 907         SETTING_TRACE("waiting..");
 908         ad->playing_volume = vol;
 909
 910         return player;
 911 }
 912
 913 #define EXP 0.001
 914 void setting_profile_play_sound_origin(player_h **mp_handle, void *data,
 915                                        void *cb, char *ringtone_file,
 916                                        /* int vol, */
 917                                        float vol,
 918                                        sound_type_e sound_type)
 919 {
 920         /* error check */
 921         ret_if(data == NULL);
 922
 923         if (vol < EXP) {
 924                 SETTING_TRACE_DEBUG("vol < EXP");
 925                 if (*mp_handle) {
 926                         if (setting_profile_stop_sound(data, *mp_handle) != SETTING_RETURN_SUCCESS) {
 927                                 /* error */
 928                         } else {
 929                                 *mp_handle = NULL;
 930                         }
 931                 }
 932                 return;
 933         }
 934
 935         SettingProfileUG *ad = (SettingProfileUG *) data;
 936         if (*mp_handle == NULL) {
 937                 *mp_handle = setting_profile_play_sound(ad, cb, ringtone_file, vol, sound_type);
 938         }
 939 }
 940
 941 int setting_profile_stop_sound(void *data, player_h *player)
 942 {
 943         SETTING_TRACE_BEGIN;
 944         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 945
 946         SettingProfileUG *ad = (SettingProfileUG *) data;
 947         if (ad->song_playing) {
 948                 g_free(ad->song_playing);
 949                 ad->song_playing = NULL;
 950         }
 951
 952         player_state_e state = -1;
 953         int ret = SETTING_RETURN_SUCCESS;
 954         int prev_behavior = 0;  /*  instead of do_while(0) and break */
 955
 956         player_get_state(*player, &state);
 957         if (state == PLAYER_STATE_PLAYING) {
 958                 if (player_stop(*player) != PLAYER_ERROR_NONE) {
 959                         SETTING_TRACE("mm player stop failed");
 960                         ret = SETTING_MMPLAYER_STOP_ERR;
 961                         prev_behavior++;        /*  instead of do_while(0) and break */
 962                 }
 963         }
 964
 965         if ((prev_behavior == 0) && (player_unprepare(*player) != PLAYER_ERROR_NONE)) {
 966                 SETTING_TRACE("mm player unrealize failed");
 967                 ret = SETTING_MMPLAYER_UNREALIZE_ERR;
 968                 prev_behavior++;        /*  instead of do_while(0) and break */
 969         }
 970
 971         if ((prev_behavior == 0) && (player_destroy(*player) != PLAYER_ERROR_NONE)) {
 972                 SETTING_TRACE("mm player destroy failed");
 973                 ret = SETTING_MMPLAYER_DESTROY_ERR;
 974         }
 975
 976         free(player);
 977         player = NULL;
 978         return ret;
 979 }
 980
 981 int __close_player(void *data, setting_volume_types type)
 982 {
 983         /* error check */
 984         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 985
 986         SettingProfileUG *ad = (SettingProfileUG *) data;
 987         player_h **player= NULL;
 988
 989         double value = 0.0;
 990
 991         switch(type)
 992         {
 993                 case SETTING_VOL_TYPE_RINGTONE:
 994                         retv_if(ad->mp_ringtone == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 995                         player = &(ad->mp_ringtone);
 996                         value = elm_slider_value_get(ad->data_call_volume->eo_check);
 997                         sound_manager_set_volume(SOUND_TYPE_RINGTONE, (unsigned int)(value+0.5));
 998                         break;
 999                 case SETTING_VOL_TYPE_NOTIFICATION:
1000                         retv_if(ad->mp_noti == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1001                         player = &(ad->mp_noti);
1002                         value = elm_slider_value_get(ad->data_noti_volume->eo_check);
1003                         sound_manager_set_volume(SOUND_TYPE_NOTIFICATION, (unsigned int)(value+0.5));
1004                         break;
1005                 case SETTING_VOL_TYPE_MEDIA:
1006                         retv_if(ad->mp_media == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1007                         player = &(ad->mp_media);
1008                         value = elm_slider_value_get(ad->data_media_volume->eo_check);
1009                         sound_manager_set_volume(SOUND_TYPE_MEDIA, (unsigned int)(value+0.5));
1010                         break;
1011                 case SETTING_VOL_TYPE_SYSTEM:
1012                         retv_if(ad->mp_sys == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1013                         player = &(ad->mp_sys);
1014                         value = elm_slider_value_get(ad->data_touch_volume->eo_check);
1015                         sound_manager_set_volume(SOUND_TYPE_SYSTEM, (unsigned int)(value+0.5));
1016                         break;
1017                 case SETTING_VOL_TYPE_NOTI_VIB:
1018                 case SETTING_VOL_TYPE_HAPTIC_VIB:
1019                 default:
1020                         return SETTING_RETURN_FAIL;
1021         }
1022
1023         if (*player) {
1024                 if (setting_profile_stop_sound(ad, *player)) {
1025                         *player = NULL;
1026                 } else {
1027                         return SETTING_RETURN_FAIL;
1028                 }
1029         }
1030
1031         return SETTING_RETURN_SUCCESS;
1032 }
1033
1034 int
1035 setting_profile_close_other_mm_players_but_type(void *data, sound_type_e type)
1036 {
1037         /* error check */
1038         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1039
1040         SettingProfileUG *ad = (SettingProfileUG *) data;
1041
1042         int ret = 0;
1043
1044         switch (type)
1045         {
1046                 case SOUND_TYPE_RINGTONE:       /*  close noti, media and system players */
1047                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1048                                 ret++;
1049                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1050                                 ret++;
1051                         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1052                                 ret++;
1053                         break;
1054                 case SOUND_TYPE_NOTIFICATION:   /*  close ringtone, media and system players */
1055                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1056                                 ret++;
1057                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1058                                 ret++;
1059                         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1060                                 ret++;
1061                         break;
1062                 case SOUND_TYPE_MEDIA:  /*  close ringtone, noti and system players */
1063                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1064                                 ret++;
1065                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1066                                 ret++;
1067                         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1068                                 ret++;
1069                         break;
1070                 case SOUND_TYPE_SYSTEM: /*  close ringtone, noti and media players */
1071                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1072                                 ret++;
1073                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1074                                 ret++;
1075                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1076                                 ret++;
1077                         break;
1078                 default:                /*  if unknown type, dont close any player */
1079                         break;
1080         }
1081
1082         if (ret == 0)
1083                 return SETTING_RETURN_SUCCESS;
1084         else
1085                 return SETTING_RETURN_FAIL;
1086 }
1087
1088 int setting_profile_close_all_mm_players(void *data)
1089 {
1090         /* error check */
1091         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1092
1093         SettingProfileUG *ad = (SettingProfileUG *) data;
1094
1095         int ret = 0;
1096
1097         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1098                 ret++;
1099         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1100                 ret++;
1101         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1102                 ret++;
1103         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1104                 ret++;
1105
1106         if(ad->volume_timer)
1107         {
1108                 ecore_timer_del(ad->volume_timer);
1109                 ad->volume_timer = NULL;
1110                 ad->cur_vol_type = SETTING_VOL_TYPE_MAX;
1111                 SETTING_TRACE_DEBUG("[AA] volume timer is deleted");
1112         }
1113
1114         if (ret == 0)
1115                 return SETTING_RETURN_SUCCESS;
1116         else
1117                 return SETTING_RETURN_FAIL;
1118 }
1119
1120 void setting_profile_play_vibration(void *data, int value)
1121 {
1122         /* error check */
1123         ret_if(data == NULL);
1124
1125         SettingProfileUG *ad = (SettingProfileUG *) data;
1126
1127         char pattern_file[MAX_COMMON_BUFFER_LEN] = {0,};
1128         svi_get_path(SVI_TYPE_VIB, value, pattern_file, sizeof(pattern_file));
1129
1130 #if MIGRATION_HAPTIC
1131         if(ad->hnd_hpt < 0)
1132         {
1133                 SETTING_TRACE_DEBUG("[ERROR] Can't use haptic handle.");
1134                 return;
1135         }
1136         if(haptic_vibrate_file_with_detail(ad->hnd_hpt, pattern_file, 1, HAPTIC_FEEDBACK_AUTO, HAPTIC_PRIORITY_MIN, NULL) != 0){
1137                 SETTING_TRACE("ERROR device_haptic_play_pattern");
1138         }
1139 #endif
1140 }
1141
1142 int setting_profile_get_call_playing_vib_by_vconf_value(int call_vib_value)
1143 {
1144         /*  select vibration pattern */
1145         switch (call_vib_value) {
1146                 case SETTING_CALL_ALERT_VIB_TYPE1:
1147                 {
1148                         return SVI_VIB_NOTIFICATION_INCOMING_CALL01;
1149                 }
1150                 case SETTING_CALL_ALERT_VIB_TYPE2:
1151                 {
1152                         return SVI_VIB_NOTIFICATION_INCOMING_CALL02;
1153                 }
1154                 case SETTING_CALL_ALERT_VIB_TYPE3:
1155                 {
1156                         return SVI_VIB_NOTIFICATION_INCOMING_CALL03;
1157                 }
1158                 default:
1159                         return SVI_VIB_NOTIFICATION_INCOMING_CALL01;
1160         }
1161 }
1162
1163 UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
1164 {
1165         SETTING_TRACE_BEGIN;
1166         int ret = 0;
1167
1168 #if SUPPORT_RUN_SYSTEM_COMMAND
1169         ret += excuteCmd(SETTING_POSTINST_FILE, 1, "sounds");
1170 #else
1171
1172         ret += vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
1173         ret += vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE); /* after support incoming call vibration, it should be change to TRUE */
1174         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SETTING_DEFAULT_NOTI_VIB_INT);
1175         ret += vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, SETTING_DEFAULT_HAPTIC_VIB_INT);
1176         ret += vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_BAK_INT, SETTING_DEFAULT_HAPTIC_VIB_INT);
1177
1178         ret += vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, SETTING_DEFAULT_CALL_TONE);
1179
1180         ret += vconf_set_int(VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_INT, SETTING_CALL_ALERT_VIB_TYPE3);
1181
1182         ret += vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, SETTING_DEFAULT_MSG_TONE);
1183         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, SETTING_DEFAULT_ALERT_REPEAT_TYPE_INT);
1184
1185         ret += vconf_set_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, SETTING_DEFAULT_EMAIL_TONE);
1186         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, SETTING_DEFAULT_ALERT_REPEAT_TYPE_INT);
1187
1188         ret += vconf_set_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, TRUE);
1189
1190         /* if ret is 0, finish completely */
1191         /* if ret is minus, it means times of failure */
1192 #endif
1193         sound_manager_set_volume(SOUND_TYPE_RINGTONE, SETTING_DEFAULT_RINGTONE_VOL_INT);
1194         sound_manager_set_volume(SOUND_TYPE_NOTIFICATION, SETTING_DEFAULT_NOTI_VOL_INT);
1195         sound_manager_set_volume(SOUND_TYPE_MEDIA, SETTING_DEFAULT_MEDIA_VOL_INT);
1196         sound_manager_set_volume(SOUND_TYPE_SYSTEM, SETTING_DEFAULT_SYSTEM_VOL_INT);
1197         return ret;
1198 }
1199