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