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