src/_sound.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <appcore-common.h>
  19 #include <mm_sound.h>
  20 #include <vconf.h>
  21 #include <svi.h>
  22
  23 #include "volume.h"
  24 #include "_util_log.h"
  25 #include "_logic.h"
  26
  27 #define STRBUF_SIZE 64
  28 #define PATHBUF_SIZE 256
  29
  30 void _play_vib(int handle)
  31 {
  32         svi_play_vib(handle, SVI_VIB_OPERATION_VIBRATION);
  33 }
  34
  35 void _play_sound(int type, int handle)
  36 {
  37         if (type == VOLUME_TYPE_MEDIA) {
  38
  39         } else {
  40                 svi_play_sound(handle, SVI_SND_TOUCH_TOUCH1);
  41         }
  42 }
  43
  44 int _init_svi(void *data)
  45 {
  46         int ret, handle;
  47
  48         struct appdata *ad = (struct appdata *)data;
  49         retvm_if(ad == NULL, -1, "Invaild argument: appdata is NULL\n");
  50
  51         ret = svi_init(&handle);
  52         if (ret != SVI_SUCCESS) {
  53                 _E("Failed to init svi\n");
  54                 svi_fini(handle);
  55                 return -1;
  56         }
  57         ad->sh = handle;
  58         return 0;
  59 }
  60
  61 int _set_slider_value(void *data, int val)
  62 {
  63         struct appdata *ad = (struct appdata *)data;
  64         retvm_if(ad == NULL, -1, "Invalid argument: appdata is NULL\n");
  65
  66         if (ad->flag_touching == EINA_TRUE) {
  67                 return 0;
  68         }
  69         if (ad->sl) {
  70                 elm_slider_min_max_set(ad->sl, 0, ad->step);
  71                 elm_slider_value_set(ad->sl, val);
  72         }
  73
  74         return 0;
  75 }
  76
  77 int _set_icon(void *data, int val)
  78 {
  79         int snd=0, vib=0;
  80         char buf[PATHBUF_SIZE] = {0, };
  81         char *img;
  82         struct appdata *ad = (struct appdata *)data;
  83         retvm_if(ad == NULL, -1, "Invalid argument: appdata is NULL\n");
  84
  85         vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &snd);
  86         vconf_get_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vib);
  87
  88         if (val == 0) {
  89                 if (vib) {
  90                         if (ad->type == VOLUME_TYPE_MEDIA) {
  91                                 _D("media and mute\n");
  92                                 img = "00_volume_icon_Mute.png";
  93                         } else {
  94                                 _D("Not media and vib\n");
  95                                 img = "00_volume_icon_Vibrat.png";
  96                                 _play_vib(ad->sh);
  97                         }
  98                 } else {
  99                         _D("vib\n");
 100                         img = "00_volume_icon_Mute.png";
 101                 }
 102         } else {
 103                 _D("default volume\n");
 104                 img = "00_volume_icon.png";
 105         }
 106
 107         if(!snd){
 108                 if(ad->type != VOLUME_TYPE_MEDIA){
 109                         _D("Not media and mute\n");
 110                         img = "00_volume_icon_Mute.png";
 111                 }
 112         }
 113
 114
 115         snprintf(buf, sizeof(buf), "%s/%s", IMAGEDIR, img);
 116         if (ad->ic ) {
 117                 elm_icon_file_set(ad->ic, buf, NULL);
 118         }
 119         return 1;
 120 }
 121
 122 void _set_device_warning(void *data, int val, int device)
 123 {
 124         struct appdata *ad = (struct appdata *)data;
 125         retm_if(ad == NULL, "Invalid argument: appdata is NULL\n");
 126
 127         switch (device) {
 128                 case SYSTEM_AUDIO_ROUTE_PLAYBACK_DEVICE_EARPHONE:
 129                         if (val >= 13) {
 130                                 if(ad->flag_warning) return;
 131                                 ad->flag_warning = true;
 132                                 elm_object_content_unset(ad->pu);
 133                                 elm_object_part_content_set(ad->warn_ly, "elm.swallow.slider1", ad->sl);
 134                                 elm_object_content_set(ad->pu, ad->warn_ly);
 135                                 evas_object_show(ad->warn_ly);
 136                                 DEL_TIMER(ad->warntimer);
 137                                 ADD_TIMER(ad->warntimer, 3.0, _unset_layout, data);
 138                         }
 139                         else {
 140                                 ad->flag_warning = false;
 141                                 _unset_layout(data);
 142                         }
 143                         break;
 144                 default:
 145                         ad->flag_warning = false;
 146                         _unset_layout(data);
 147                         break;
 148         }
 149 }
 150
 151 int _get_title(volume_type_t type, char *label, int size)
 152 {
 153         char *text = NULL;
 154
 155         text = S_("IDS_COM_BODY_UNKNOWN");
 156
 157         switch (type) {
 158         case VOLUME_TYPE_SYSTEM:
 159                 text = S_("IDS_COM_BODY_SYSTEM");
 160                 break;
 161         case VOLUME_TYPE_NOTIFICATION:
 162                 text = S_("IDS_COM_HEADER_NOTIFICATION");
 163                 break;
 164         case VOLUME_TYPE_ALARM:
 165                 text = S_("IDS_COM_BODY_ALARM");
 166                 break;
 167         case VOLUME_TYPE_RINGTONE:
 168                 text = S_("IDS_COM_BODY_RINGTONE");
 169                 break;
 170         case VOLUME_TYPE_MEDIA:
 171                 text = T_("IDS_COM_BODY_MEDIA");
 172                 break;
 173         case VOLUME_TYPE_CALL:
 174                 text = S_("IDS_COM_BODY_CALL");
 175                 break;
 176         case VOLUME_TYPE_EXT_ANDROID:
 177                 /* this enum is different from mm_sound.h and avsys-audio.h */
 178                 text = T_("IDS_COM_BODY_ANDROID");
 179                 break;
 180         case VOLUME_TYPE_EXT_JAVA:
 181                 text = T_("IDS_COM_BODY_JAVA");
 182                 break;
 183         default:
 184                 text = S_("IDS_COM_BODY_SYSTEM");
 185                 break;
 186         }
 187         snprintf(label, size, "%s", text);
 188         _D("get title(%s)\n", label);
 189
 190         return 0;
 191 }
 192
 193 void _set_popup_title(void *data, int type, int device)
 194 {
 195         char buf[STRBUF_SIZE] = {0, };
 196         char name[STRBUF_SIZE] = {0, };
 197         struct appdata *ad = (struct appdata *)data;
 198         retm_if(ad == NULL, "Invalid argument: appdata is NULL\n");
 199
 200         _get_title(type, buf, sizeof(buf));
 201
 202         switch (device) {
 203                 case SYSTEM_AUDIO_ROUTE_PLAYBACK_DEVICE_EARPHONE:
 204                         snprintf(name, sizeof(name), "%s (%s)", buf, T_("IDS_COM_OPT_HEADPHONES_ABB"));
 205                         elm_object_part_text_set(ad->pu, "title,text", name);
 206                         break;
 207                 default:
 208                         elm_object_part_text_set(ad->pu, "title,text", buf);
 209                         break;
 210         }
 211 }
 212
 213 int _get_step(int type)
 214 {
 215         int ret, step;
 216         ret = mm_sound_volume_get_step(type, &step);
 217         retvm_if(ret < 0, -1, "Failed to get step\n");
 218         step -= 1;
 219         return step;
 220 }
 221
 222 void _mm_func(void *data)
 223 {
 224         _D("%s\n", __func__);
 225         int val;
 226         system_audio_route_device_t device = 0;
 227         struct appdata *ad = (struct appdata *)data;
 228         retm_if(ad == NULL, "Invalid argument: appdata is NULL\n");
 229
 230         retm_if(ad->win == NULL, "Failed to get window\n");
 231
 232         /* function could be activated when window exists */
 233         ad->step = _get_step(ad->type);
 234         mm_sound_volume_get_value(ad->type, (unsigned int*)(&val));
 235         mm_sound_route_get_playing_device(&device);
 236
 237         _set_slider_value(ad, val);
 238         _set_popup_title(ad, ad->type, device);
 239         _set_device_warning(ad, val, device);
 240         _set_icon(ad, val);
 241         _D("type(%d) val(%d)\n", ad->type, val);
 242 }
 243
 244 void _mm_system_cb(void *data)
 245 {
 246         _mm_func(data);
 247 }
 248
 249 void _mm_notification_cb(void *data)
 250 {
 251         _mm_func(data);
 252 }
 253
 254 void _mm_alarm_cb(void *data)
 255 {
 256         _mm_func(data);
 257 }
 258
 259 void _mm_ringtone_cb(void *data)
 260 {
 261         _mm_func(data);
 262 }
 263
 264 void _mm_media_cb(void *data)
 265 {
 266         _mm_func(data);
 267 }
 268
 269 void _mm_call_cb(void *data)
 270 {
 271         _mm_func(data);
 272 }
 273
 274 void _mm_ext_android_cb(void *data)
 275 {
 276         _mm_func(data);
 277 }
 278
 279 void _mm_ext_java_cb(void *data)
 280 {
 281         _mm_func(data);
 282 }
 283
 284 int _get_volume_type_max(void)
 285 {
 286         return VOLUME_TYPE_MAX;
 287 }
 288
 289 int _init_mm_sound(void *data)
 290 {
 291         struct appdata *ad = (struct appdata *)data;
 292         retvm_if(ad == NULL, -1, "Invalid argument: appdata is NULL\n");
 293
 294         mm_sound_volume_add_callback(VOLUME_TYPE_SYSTEM,
 295                         _mm_system_cb, (void *)ad);
 296         mm_sound_volume_add_callback(VOLUME_TYPE_NOTIFICATION,
 297                         _mm_notification_cb, (void *)ad);
 298         mm_sound_volume_add_callback(VOLUME_TYPE_ALARM,
 299                         _mm_alarm_cb, (void *)ad);
 300         mm_sound_volume_add_callback(VOLUME_TYPE_RINGTONE,
 301                         _mm_ringtone_cb, (void *)ad);
 302         mm_sound_volume_add_callback(VOLUME_TYPE_MEDIA,
 303                         _mm_media_cb, (void *)ad);
 304         mm_sound_volume_add_callback(VOLUME_TYPE_CALL,
 305                         _mm_call_cb, (void *)ad);
 306         mm_sound_volume_add_callback(VOLUME_TYPE_EXT_ANDROID,
 307                         _mm_ext_android_cb, (void *)ad);
 308         mm_sound_volume_add_callback(VOLUME_TYPE_EXT_JAVA,
 309                         _mm_ext_java_cb, (void *)ad);
 310
 311         return 0;
 312 }
 313
 314 int _get_sound_level(volume_type_t type, int *val)
 315 {
 316         mm_sound_volume_get_value(type, (unsigned int*)val);
 317         return 0;
 318 }
 319
 320 int _set_sound_level(volume_type_t type, int val)
 321 {
 322         mm_sound_volume_set_value(type, val);
 323         return 0;
 324 }