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