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