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                                 return;
 561
 562                         profileUG->data_msg_alert_tone->sub_desc = setting_file_basename(pa_tone_path);
 563                         elm_genlist_item_update(profileUG->data_msg_alert_tone->item);
 564                 }
 565
 566                 FREE(pa_tone_path);
 567
 568         }
 569
 570         /* 3. email ringtone */
 571         if(profileUG->data_email_alert_tone)
 572         {
 573                 SETTING_TRACE_DEBUG("change email_alert_tone %x", profileUG->data_email_alert_tone);
 574                 pa_tone_path = vconf_get_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR);
 575                 if((pa_tone_path == NULL) || (setting_profile_check_file_exist(profileUG, pa_tone_path) == SETTING_RETURN_FAIL))
 576                 {
 577                         pa_tone_path = (char *)strdup(SETTING_DEFAULT_MSG_TONE);
 578                         if(vconf_set_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, SETTING_DEFAULT_MSG_TONE) < 0)
 579                                 return;
 580                         profileUG->data_email_alert_tone->sub_desc = setting_file_basename(pa_tone_path);
 581                         elm_genlist_item_update(profileUG->data_email_alert_tone->item);
 582                 }
 583
 584                 FREE(pa_tone_path);
 585
 586         }
 587 }
 588
 589 static void setting_profile_ug_on_destroy(ui_gadget_h ug, service_h service, void *priv)
 590 {
 591         ret_if(priv == NULL);
 592
 593         SettingProfileUG *profileUG = priv;
 594
 595         setting_profile_unlisten_vconf_change(profileUG);
 596         evas_object_event_callback_del(profileUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_profile_ug_cb_resize); /* fix flash issue for gallery */
 597         profileUG->ug = ug;
 598 #if DISABLED_CODE
 599         //At present, there are only 4 types supported:RINGTONE,NOTIFICATION,SYSTEM,MEDIA
 600         sound_manager_unset_volume_changed_cb();
 601 #endif
 602
 603         int ret = haptic_close(profileUG->hnd_hpt);
 604         if (ret != 0) {
 605                 SETTING_TRACE_DEBUG("%s*** [ERR] Failed haptic_deinitialize ***%s",
 606                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
 607         }
 608         setting_profile_close_all_mm_players(profileUG);
 609
 610         /* it is the view manage strategy to invoke view's destory operation. */
 611         setting_view_destroy(&setting_view_profile_sound_main, profileUG);
 612         if (NULL != ug_get_layout(profileUG->ug)) {
 613                 evas_object_hide((Evas_Object *) ug_get_layout(profileUG->ug));
 614                 evas_object_del((Evas_Object *) ug_get_layout(profileUG->ug));
 615         }
 616 }
 617
 618 static void setting_profile_ug_on_message(ui_gadget_h ug, service_h msg,
 619                                           service_h service, void *priv)
 620 {
 621
 622 }
 623
 624 static void setting_profile_ug_on_event(ui_gadget_h ug,
 625                                         enum ug_event event, service_h service, void *priv)
 626 {
 627         SETTING_TRACE_BEGIN;
 628         SettingProfileUG *ad = (SettingProfileUG *)priv;
 629
 630         switch (event) {
 631                 case UG_EVENT_LOW_MEMORY:
 632                         break;
 633                 case UG_EVENT_LOW_BATTERY:
 634                         break;
 635                 case UG_EVENT_LANG_CHANGE:
 636                         break;
 637                 case UG_EVENT_ROTATE_PORTRAIT:
 638                         break;
 639                 case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 640                         break;
 641                 case UG_EVENT_ROTATE_LANDSCAPE:
 642                         break;
 643                 case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 644                         break;
 645                 case UG_EVENT_REGION_CHANGE:
 646                         break;
 647                 default:
 648                         break;
 649         }
 650 }
 651
 652 static void setting_profile_ug_on_key_event(ui_gadget_h ug,
 653                                             enum ug_key_event event, service_h service, void *priv)
 654 {
 655         ret_if(priv == NULL);
 656
 657         SettingProfileUG *ad = (SettingProfileUG *) priv;
 658
 659         switch (event) {
 660                 case UG_KEY_EVENT_END:
 661                         if (elm_naviframe_top_item_get(ad->navi_bar) ==
 662                             elm_naviframe_bottom_item_get(ad->navi_bar)) {
 663                                 ug_destroy_me(ug);
 664                         } else {
 665                                 if (&setting_view_profile_sound_main ==
 666                                     setting_view_node_get_cur_view()) {
 667
 668                                         /* close mm plaer */
 669                                         setting_profile_close_all_mm_players(ad);
 670                                         /* close vibration */
 671                                 #if MIGRATION_HAPTIC
 672                                         if (haptic_stop_all_effects(ad->hnd_hpt) != 0) {
 673                                                 SETTING_TRACE("ERROR haptic_stop_all_effects");
 674                                         }
 675                                 #endif
 676                                 }
 677                                 setting_view_cb_at_endKey(ad);
 678                         }
 679                         break;
 680                 default:
 681                         break;
 682         }
 683 }
 684
 685 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 686 {
 687         SETTING_TRACE_BEGIN;
 688         //appcore_measure_start();
 689         SettingProfileUG *profileUG = calloc(1, sizeof(SettingProfileUG));
 690         setting_retvm_if(!profileUG, -1, "Create SettingProfileUG obj failed");
 691
 692         ops->create = setting_profile_ug_on_create;
 693         ops->start = setting_profile_ug_on_start;
 694         ops->pause = setting_profile_ug_on_pause;
 695         ops->resume = setting_profile_ug_on_resume;
 696         ops->destroy = setting_profile_ug_on_destroy;
 697         ops->message = setting_profile_ug_on_message;
 698         ops->event = setting_profile_ug_on_event;
 699         ops->key_event = setting_profile_ug_on_key_event;
 700         ops->priv = profileUG;
 701         ops->opt = UG_OPT_INDICATOR_ENABLE;
 702         /* Haptic init */
 703         SETTING_TRACE("before haptic initilization");
 704         int haptic_return = 0;
 705         haptic_return = haptic_open(HAPTIC_DEVICE_0, &(profileUG->hnd_hpt));
 706         SETTING_TRACE("profileUG->hnd_hpt : %d", profileUG->hnd_hpt);
 707         if (haptic_return < 0) {
 708                 SETTING_TRACE_DEBUG("%s*** [ERR] Failed haptic_open ***%s",
 709                                                 SETTING_FONT_RED, SETTING_FONT_BLACK);
 710         }
 711
 712         return 0;
 713 }
 714
 715 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 716 {
 717         ret_if(ops == NULL);
 718
 719         struct SettingProfileUG *profileUG;
 720         profileUG = ops->priv;
 721         if (profileUG)
 722                 FREE(profileUG);
 723 }
 724
 725 /* ***************************************************
 726  *
 727  *general func
 728  *
 729  ***************************************************/
 730
 731 int setting_profile_check_file_exist(void *data, const char *file_path)
 732 {
 733         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 734         retv_if(file_path == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 735
 736         if (!ecore_file_exists(file_path)) {
 737                 SETTING_TRACE_ERROR("Cannot find the ringtone file[%s]!", file_path);
 738                 return SETTING_RETURN_FAIL;
 739         }
 740
 741         int mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
 742         vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_status);
 743         if (VCONFKEY_SYSMAN_MMC_MOUNTED != mmc_status)
 744         {
 745                 if (!safeStrNCmp(SETTING_PROFILE_MMC_PATH, file_path, safeStrLen(SETTING_PROFILE_MMC_PATH)))
 746                 {
 747                         return SETTING_RETURN_FAIL;
 748                 }
 749         }
 750         return SETTING_RETURN_SUCCESS;
 751 }
 752
 753 player_h *setting_profile_play_sound(void *data, void *cb,
 754                                  char *ringtone_file,
 755                                  int vol,
 756                                  sound_type_e sound_type)
 757 {
 758         /* error check */
 759         retv_if(data == NULL, NULL);
 760
 761         SettingProfileUG *ad = (SettingProfileUG *) data;
 762
 763         int is_existing = setting_profile_check_file_exist(ad, ringtone_file);
 764         if(is_existing == SETTING_RETURN_FAIL || NULL == ringtone_file)
 765         {
 766                 char pattern_file[MAX_COMMON_BUFFER_LEN] = {0,};
 767                 switch(sound_type)
 768                 {
 769                         case SOUND_TYPE_RINGTONE:
 770                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
 771                                 break;
 772                         case SOUND_TYPE_MEDIA:
 773                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MEDIA_TONE);
 774                                 break;
 775                         case SOUND_TYPE_NOTIFICATION:
 776                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_MSG_TONE);
 777                                 break;
 778                         case SOUND_TYPE_SYSTEM:
 779                                 svi_get_path(SVI_TYPE_SND, SVI_SND_TOUCH_TOUCH1, pattern_file, sizeof(pattern_file));
 780                                 retv_if(pattern_file == NULL, NULL);
 781                                 ad->song_playing = (char *)g_strdup(pattern_file);
 782                                 break;
 783                         default:
 784                                 ad->song_playing = (char *)g_strdup(SETTING_DEFAULT_CALL_TONE);
 785                                 break;
 786                 }
 787
 788         }
 789         else {
 790                 ad->song_playing = (char *)g_strdup(ringtone_file);
 791         }
 792
 793         player_h *player = calloc(1, sizeof(player_h));
 794         if (!player) {
 795                 SETTING_TRACE_ERROR("failed to calloc player_h");
 796                 return NULL;
 797         }
 798
 799         int err = 0;
 800
 801         err = player_create(player);
 802         if (err != PLAYER_ERROR_NONE) {
 803                 SETTING_TRACE_ERROR("creating the player handle failed[%d]", err);
 804                 free(player);
 805                 return NULL;
 806         }
 807
 808         err = player_set_sound_type(*player, sound_type);
 809         if (err != PLAYER_ERROR_NONE) {
 810                 SETTING_TRACE_ERROR("error to set sound_type[%d]", err);
 811                 player_destroy(*player);
 812                 free(player);
 813                 return NULL;
 814         }
 815         SETTING_TRACE_DEBUG("player_set_sound_type [%d]", sound_type);
 816
 817         err = player_set_uri(*player, ad->song_playing);
 818         if (err != PLAYER_ERROR_NONE) {
 819                 SETTING_TRACE_ERROR("error to set attribute---profile_uri[%d]", err);
 820                 player_destroy(*player);
 821                 free(player);
 822                 return NULL;
 823         }
 824
 825         err = player_prepare(*player);
 826         if (err != PLAYER_ERROR_NONE) {
 827                 SETTING_TRACE_ERROR("realizing the player handle failed[%d]", err);
 828                 player_destroy(*player);
 829                 free(player);
 830                 return NULL;
 831         }
 832
 833         player_state_e state = -1;
 834         player_get_state(*player, &state);
 835         SETTING_TRACE("state:%d", state);
 836
 837         if (state != PLAYER_STATE_READY) {
 838                 SETTING_TRACE_ERROR("state of player is invalid %d", err);
 839                 player_unprepare(*player);
 840                 player_destroy(*player);
 841                 free(player);
 842                 return NULL;
 843         }
 844
 845         player_set_completed_cb(*player, cb, ad);
 846         err = player_start(*player);
 847         if (err != PLAYER_ERROR_NONE) { /* if directly return error.. */
 848                 SETTING_TRACE_ERROR("player_start [%d]", err);
 849                 player_unset_completed_cb(*player);
 850                 player_unprepare(*player);
 851                 player_destroy(*player);
 852                 free(player);
 853                 return NULL;
 854         }
 855
 856         SETTING_TRACE("waiting..");
 857         ad->playing_volume = vol;
 858
 859         return player;
 860 }
 861
 862 #define EXP 0.001
 863 void setting_profile_play_sound_origin(player_h **mp_handle, void *data,
 864                                        void *cb, char *ringtone_file,
 865                                        /* int vol, */
 866                                        float vol,
 867                                        sound_type_e sound_type)
 868 {
 869         /* error check */
 870         ret_if(data == NULL);
 871
 872         if (vol < EXP) {
 873                 SETTING_TRACE_DEBUG("vol < EXP");
 874                 if (*mp_handle) {
 875                         if (setting_profile_stop_sound(data, *mp_handle) != SETTING_RETURN_SUCCESS) {
 876                                 /* error */
 877                         } else {
 878                                 *mp_handle = NULL;
 879                         }
 880                 }
 881                 return;
 882         }
 883
 884         SettingProfileUG *ad = (SettingProfileUG *) data;
 885         if (*mp_handle == NULL) {
 886                 *mp_handle = setting_profile_play_sound(ad, cb, ringtone_file, vol, sound_type);
 887         }
 888 }
 889
 890 int setting_profile_stop_sound(void *data, player_h *player)
 891 {
 892         SETTING_TRACE_BEGIN;
 893         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 894
 895         SettingProfileUG *ad = (SettingProfileUG *) data;
 896         if (ad->song_playing) {
 897                 g_free(ad->song_playing);
 898                 ad->song_playing = NULL;
 899         }
 900
 901         player_state_e state = -1;
 902         int ret = SETTING_RETURN_SUCCESS;
 903         int prev_behavior = 0;  /*  instead of do_while(0) and break */
 904
 905         player_get_state(*player, &state);
 906         if (state == PLAYER_STATE_PLAYING) {
 907                 if (player_stop(*player) != PLAYER_ERROR_NONE) {
 908                         SETTING_TRACE("mm player stop failed");
 909                         ret = SETTING_MMPLAYER_STOP_ERR;
 910                         prev_behavior++;        /*  instead of do_while(0) and break */
 911                 }
 912         }
 913
 914         if ((prev_behavior == 0) && (player_unprepare(*player) != PLAYER_ERROR_NONE)) {
 915                 SETTING_TRACE("mm player unrealize failed");
 916                 ret = SETTING_MMPLAYER_UNREALIZE_ERR;
 917                 prev_behavior++;        /*  instead of do_while(0) and break */
 918         }
 919
 920         if ((prev_behavior == 0) && (player_destroy(*player) != PLAYER_ERROR_NONE)) {
 921                 SETTING_TRACE("mm player destroy failed");
 922                 ret = SETTING_MMPLAYER_DESTROY_ERR;
 923         }
 924
 925         free(player);
 926         player = NULL;
 927         return ret;
 928 }
 929
 930 int __close_player(void *data, setting_volume_types type)
 931 {
 932         /* error check */
 933         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 934
 935         SettingProfileUG *ad = (SettingProfileUG *) data;
 936         player_h **player= NULL;
 937
 938         double value = 0.0;
 939
 940         switch(type)
 941         {
 942                 case SETTING_VOL_TYPE_RINGTONE:
 943                         retv_if(ad->mp_ringtone == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 944                         player = &(ad->mp_ringtone);
 945                         value = elm_slider_value_get(ad->data_call_volume->eo_check);
 946                         sound_manager_set_volume(SOUND_TYPE_RINGTONE, (unsigned int)(value+0.5));
 947                         break;
 948                 case SETTING_VOL_TYPE_NOTIFICATION:
 949                         retv_if(ad->mp_noti == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 950                         player = &(ad->mp_noti);
 951                         value = elm_slider_value_get(ad->data_noti_volume->eo_check);
 952                         sound_manager_set_volume(SOUND_TYPE_NOTIFICATION, (unsigned int)(value+0.5));
 953                         break;
 954                 case SETTING_VOL_TYPE_MEDIA:
 955                         retv_if(ad->mp_media == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 956                         player = &(ad->mp_media);
 957                         value = elm_slider_value_get(ad->data_media_volume->eo_check);
 958                         sound_manager_set_volume(SOUND_TYPE_MEDIA, (unsigned int)(value+0.5));
 959                         break;
 960                 case SETTING_VOL_TYPE_SYSTEM:
 961                         retv_if(ad->mp_sys == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 962                         player = &(ad->mp_sys);
 963                         value = elm_slider_value_get(ad->data_touch_volume->eo_check);
 964                         sound_manager_set_volume(SOUND_TYPE_SYSTEM, (unsigned int)(value+0.5));
 965                         break;
 966                 case SETTING_VOL_TYPE_NOTI_VIB:
 967                 case SETTING_VOL_TYPE_HAPTIC_VIB:
 968                 default:
 969                         return SETTING_RETURN_FAIL;
 970         }
 971
 972         if (*player) {
 973                 if (setting_profile_stop_sound(ad, *player)) {
 974                         *player = NULL;
 975                 } else {
 976                         return SETTING_RETURN_FAIL;
 977                 }
 978         }
 979
 980         return SETTING_RETURN_SUCCESS;
 981 }
 982
 983 int
 984 setting_profile_close_other_mm_players_but_type(void *data, sound_type_e type)
 985 {
 986         /* error check */
 987         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 988
 989         SettingProfileUG *ad = (SettingProfileUG *) data;
 990
 991         int ret = 0;
 992
 993         switch (type)
 994         {
 995                 case SOUND_TYPE_RINGTONE:       /*  close noti, media and system players */
 996                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
 997                                 ret++;
 998                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != 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_NOTIFICATION:   /*  close ringtone, media and system players */
1004                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1005                                 ret++;
1006                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1007                                 ret++;
1008                         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1009                                 ret++;
1010                         break;
1011                 case SOUND_TYPE_MEDIA:  /*  close ringtone, noti and system players */
1012                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1013                                 ret++;
1014                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1015                                 ret++;
1016                         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1017                                 ret++;
1018                         break;
1019                 case SOUND_TYPE_SYSTEM: /*  close ringtone, noti and media players */
1020                         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1021                                 ret++;
1022                         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1023                                 ret++;
1024                         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1025                                 ret++;
1026                         break;
1027                 default:                /*  if unknown type, dont close any player */
1028                         break;
1029         }
1030
1031         if (ret == 0)
1032                 return SETTING_RETURN_SUCCESS;
1033         else
1034                 return SETTING_RETURN_FAIL;
1035 }
1036
1037 int setting_profile_close_all_mm_players(void *data)
1038 {
1039         /* error check */
1040         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1041
1042         SettingProfileUG *ad = (SettingProfileUG *) data;
1043
1044         int ret = 0;
1045
1046         if (__close_player(ad, SETTING_VOL_TYPE_RINGTONE) != SETTING_RETURN_SUCCESS)
1047                 ret++;
1048         if (__close_player(ad, SETTING_VOL_TYPE_NOTIFICATION) != SETTING_RETURN_SUCCESS)
1049                 ret++;
1050         if (__close_player(ad, SETTING_VOL_TYPE_MEDIA) != SETTING_RETURN_SUCCESS)
1051                 ret++;
1052         if (__close_player(ad, SETTING_VOL_TYPE_SYSTEM) != SETTING_RETURN_SUCCESS)
1053                 ret++;
1054
1055         if(ad->volume_timer)
1056         {
1057                 ecore_timer_del(ad->volume_timer);
1058                 ad->volume_timer = NULL;
1059                 ad->cur_vol_type = SETTING_VOL_TYPE_MAX;
1060                 SETTING_TRACE_DEBUG("[AA] volume timer is deleted");
1061         }
1062
1063         if (ret == 0)
1064                 return SETTING_RETURN_SUCCESS;
1065         else
1066                 return SETTING_RETURN_FAIL;
1067 }
1068
1069 void setting_profile_play_vibration(void *data, int value)
1070 {
1071         /* error check */
1072         ret_if(data == NULL);
1073
1074         SettingProfileUG *ad = (SettingProfileUG *) data;
1075
1076         char pattern_file[MAX_COMMON_BUFFER_LEN] = {0,};
1077         svi_get_path(SVI_TYPE_VIB, value, pattern_file, sizeof(pattern_file));
1078
1079 #if MIGRATION_HAPTIC
1080         if(ad->hnd_hpt < 0)
1081         {
1082                 SETTING_TRACE_DEBUG("[ERROR] Can't use haptic handle.");
1083                 return;
1084         }
1085         if(haptic_vibrate_file_with_detail(ad->hnd_hpt, pattern_file, 1, HAPTIC_FEEDBACK_AUTO, HAPTIC_PRIORITY_MIN, NULL) != 0){
1086                 SETTING_TRACE("ERROR device_haptic_play_pattern");
1087         }
1088 #endif
1089 }
1090
1091 int setting_profile_get_call_playing_vib_by_vconf_value(int call_vib_value)
1092 {
1093         /*  select vibration pattern */
1094         switch (call_vib_value) {
1095                 case SETTING_CALL_ALERT_VIB_TYPE1:
1096                 {
1097                         return SVI_VIB_NOTIFICATION_INCOMING_CALL01;
1098                 }
1099                 case SETTING_CALL_ALERT_VIB_TYPE2:
1100                 {
1101                         return SVI_VIB_NOTIFICATION_INCOMING_CALL02;
1102                 }
1103                 case SETTING_CALL_ALERT_VIB_TYPE3:
1104                 {
1105                         return SVI_VIB_NOTIFICATION_INCOMING_CALL03;
1106                 }
1107                 default:
1108                         return SVI_VIB_NOTIFICATION_INCOMING_CALL01;
1109         }
1110 }
1111
1112 UG_MODULE_API int setting_plugin_reset(service_h service, void *priv)
1113 {
1114         SETTING_TRACE_BEGIN;
1115         int ret = 0;
1116
1117 #if SUPPORT_RUN_SYSTEM_COMMAND
1118         ret += excuteCmd(SETTING_POSTINST_FILE, 1, "sounds");
1119 #else
1120
1121         ret += vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, TRUE);
1122         ret += vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, FALSE); /* after support incoming call vibration, it should be change to TRUE */
1123         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SETTING_DEFAULT_NOTI_VIB_INT);
1124         ret += vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, SETTING_DEFAULT_HAPTIC_VIB_INT);
1125         ret += vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_BAK_INT, SETTING_DEFAULT_HAPTIC_VIB_INT);
1126
1127         ret += vconf_set_str(VCONFKEY_SETAPPL_CALL_RINGTONE_PATH_STR, SETTING_DEFAULT_CALL_TONE);
1128
1129         ret += vconf_set_int(VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_INT, SETTING_CALL_ALERT_VIB_TYPE3);
1130
1131         ret += vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, SETTING_DEFAULT_MSG_TONE);
1132         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, SETTING_DEFAULT_ALERT_REPEAT_TYPE_INT);
1133
1134         ret += vconf_set_str(VCONFKEY_SETAPPL_NOTI_EMAIL_RINGTONE_PATH_STR, SETTING_DEFAULT_EMAIL_TONE);
1135         ret += vconf_set_int(VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, SETTING_DEFAULT_ALERT_REPEAT_TYPE_INT);
1136
1137         ret += vconf_set_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, TRUE);
1138
1139         /* if ret is 0, finish completely */
1140         /* if ret is minus, it means times of failure */
1141 #endif
1142         sound_manager_set_volume(SOUND_TYPE_RINGTONE, SETTING_DEFAULT_RINGTONE_VOL_INT);
1143         sound_manager_set_volume(SOUND_TYPE_NOTIFICATION, SETTING_DEFAULT_NOTI_VOL_INT);
1144         sound_manager_set_volume(SOUND_TYPE_MEDIA, SETTING_DEFAULT_MEDIA_VOL_INT);
1145         sound_manager_set_volume(SOUND_TYPE_SYSTEM, SETTING_DEFAULT_SYSTEM_VOL_INT);
1146         return ret;
1147 }
1148