svi.c

   1 /*
   2  *  libsvi
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seokkyu Jang <seokkyu.jang@samsung.com>
   7  * Contact: Sangil Yoon <si83.yoon@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #define _GNU_SOURCE
  24
  25 #include <stdio.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28
  29 #include <mm_sound_private.h>
  30 #include <vconf.h>
  31 #include <devman_haptic.h>
  32
  33 #include <svi.h>
  34 #include "svi-log.h"
  35
  36 #define SVI_DATA_DIR "/usr/share/svi"
  37 #define SVI_SOUND_DIR SVI_DATA_DIR"/sound"
  38 #define SVI_HAPTIC_DIR SVI_DATA_DIR"/haptic"
  39
  40 #define SOUND_TOUCH_DIR SVI_SOUND_DIR"/touch"
  41 #define HAPTIC_TOUCH_DIR SVI_HAPTIC_DIR"/touch"
  42
  43 #define HAPTIC_NOTI_DIR SVI_HAPTIC_DIR"/notification"
  44
  45 #define SOUND_OPER_DIR SVI_SOUND_DIR"/operation"
  46 #define HAPTIC_OPER_DIR SVI_HAPTIC_DIR"/operation"
  47
  48
  49 #ifndef API
  50 #define API __attribute__ ((visibility("default")))
  51 #endif
  52
  53 //#define PERFORM_CHECK
  54
  55 #ifdef PERFORM_CHECK
  56 static long long ms = 0;
  57
  58 #define MICROSECONDS(tv)        ((tv.tv_sec * 1000000ll) + tv.tv_usec)
  59
  60 #define ESTIMATE_PERFORMANCE() \
  61         do { \
  62                 struct timeval tv; \
  63                 if (ms == 0) { \
  64                         gettimeofday(&tv, NULL); \
  65                         ms = MICROSECONDS(tv); \
  66                         fprintf(stderr, "%s start time : %lld\n", __func__, ms); \
  67                 } else { \
  68                         gettimeofday(&tv, NULL); \
  69                         fprintf(stderr, "%s elapsed time : %lld\n", __func__, MICROSECONDS(tv) - ms); \
  70                         ms = 0; \
  71                 } \
  72         } while(0)
  73 #else
  74 #define ESTIMATE_PERFORMANCE()
  75 #endif
  76
  77 const char* snd_file[] = {
  78         SOUND_TOUCH_DIR"/touch1.wav",
  79         SOUND_TOUCH_DIR"/touch2.wav",
  80         SOUND_TOUCH_DIR"/touch3.wav",
  81         SOUND_TOUCH_DIR"/sip.wav",
  82         SOUND_TOUCH_DIR"/hold.wav",
  83         SOUND_TOUCH_DIR"/multi_tap.wav",
  84         SOUND_TOUCH_DIR"/hw_tap.wav",
  85         SOUND_TOUCH_DIR"/hw_hold.wav",
  86
  87         SOUND_TOUCH_DIR"/key0.wav",
  88         SOUND_TOUCH_DIR"/key1.wav",
  89         SOUND_TOUCH_DIR"/key2.wav",
  90         SOUND_TOUCH_DIR"/key3.wav",
  91         SOUND_TOUCH_DIR"/key4.wav",
  92         SOUND_TOUCH_DIR"/key5.wav",
  93         SOUND_TOUCH_DIR"/key6.wav",
  94         SOUND_TOUCH_DIR"/key7.wav",
  95         SOUND_TOUCH_DIR"/key8.wav",
  96         SOUND_TOUCH_DIR"/key9.wav",
  97         SOUND_TOUCH_DIR"/keyasterisk.wav",
  98         SOUND_TOUCH_DIR"/keysharp.wav",
  99
 100         SOUND_OPER_DIR"/power_on.wav",
 101         SOUND_OPER_DIR"/power_off.wav",
 102         SOUND_OPER_DIR"/charger_connection.wav",
 103         SOUND_OPER_DIR"/fully_charged.wav",
 104         SOUND_OPER_DIR"/low_battery.wav",
 105         SOUND_OPER_DIR"/lock.wav",
 106         SOUND_OPER_DIR"/unlock.wav",
 107         SOUND_OPER_DIR"/call_connect.wav",
 108         SOUND_OPER_DIR"/call_disconnect.wav",
 109         SOUND_OPER_DIR"/minute_minder.wav",
 110         SOUND_OPER_DIR"/vibration.wav",
 111         SOUND_OPER_DIR"/new_chat.wav",
 112         SOUND_OPER_DIR"/sent_chat.wav",
 113         SOUND_OPER_DIR"/on_off_slider.wav",
 114         SOUND_OPER_DIR"/shutter.wav",
 115 };
 116
 117 const char* haptic_file[] = {
 118         HAPTIC_TOUCH_DIR"/touch.ivt",
 119         HAPTIC_TOUCH_DIR"/sip.ivt",
 120         HAPTIC_TOUCH_DIR"/hold.ivt",
 121         HAPTIC_TOUCH_DIR"/multi_tap.ivt",
 122         HAPTIC_TOUCH_DIR"/hw_tap.ivt",
 123         HAPTIC_TOUCH_DIR"/hw_hold.ivt",
 124
 125         HAPTIC_TOUCH_DIR"/key0.ivt",
 126         HAPTIC_TOUCH_DIR"/key1.ivt",
 127         HAPTIC_TOUCH_DIR"/key2.ivt",
 128         HAPTIC_TOUCH_DIR"/key3.ivt",
 129         HAPTIC_TOUCH_DIR"/key4.ivt",
 130         HAPTIC_TOUCH_DIR"/key5.ivt",
 131         HAPTIC_TOUCH_DIR"/key6.ivt",
 132         HAPTIC_TOUCH_DIR"/key7.ivt",
 133         HAPTIC_TOUCH_DIR"/key8.ivt",
 134         HAPTIC_TOUCH_DIR"/key9.ivt",
 135         HAPTIC_TOUCH_DIR"/keyasterisk.ivt",
 136         HAPTIC_TOUCH_DIR"/keysharp.ivt",
 137
 138         HAPTIC_NOTI_DIR"/incoming_call1.ivt",
 139         HAPTIC_NOTI_DIR"/incoming_call2.ivt",
 140         HAPTIC_NOTI_DIR"/incoming_call3.ivt",
 141         HAPTIC_NOTI_DIR"/message.ivt",
 142         HAPTIC_NOTI_DIR"/email.ivt",
 143         HAPTIC_NOTI_DIR"/wakeup.ivt",
 144         HAPTIC_NOTI_DIR"/schedule.ivt",
 145         HAPTIC_NOTI_DIR"/timer.ivt",
 146         HAPTIC_NOTI_DIR"/general.ivt",
 147
 148         HAPTIC_OPER_DIR"/power_on.ivt",
 149         HAPTIC_OPER_DIR"/power_off.ivt",
 150         HAPTIC_OPER_DIR"/charger_connection.ivt",
 151         HAPTIC_OPER_DIR"/fully_charged.ivt",
 152         HAPTIC_OPER_DIR"/low_battery.ivt",
 153         HAPTIC_OPER_DIR"/lock.ivt",
 154         HAPTIC_OPER_DIR"/unlock.ivt",
 155         HAPTIC_OPER_DIR"/call_connect.ivt",
 156         HAPTIC_OPER_DIR"/call_disconnect.ivt",
 157         HAPTIC_OPER_DIR"/minute_minder.ivt",
 158         HAPTIC_OPER_DIR"/vibration.ivt",
 159         HAPTIC_OPER_DIR"/new_chat.ivt",
 160         HAPTIC_OPER_DIR"/sent_chat.ivt",
 161         HAPTIC_OPER_DIR"/on_off_slider.ivt",
 162         HAPTIC_OPER_DIR"/shutter.ivt",
 163 };
 164
 165 static int soundon = -1;
 166 static int vib_level = -1;
 167 static int sndstatus = -1;
 168 static int vibstatus = -1;
 169
 170 void soundon_cb(keynode_t *key, void* data)
 171 {
 172         soundon = vconf_keynode_get_bool(key);
 173         SVILOG("[[[[[[[[[[[[[[soundon changed!! new soundon => %d\n", soundon);
 174         return;
 175 }
 176
 177 void vib_cb(keynode_t *key, void* data)
 178 {
 179         vib_level = vconf_keynode_get_int(key);
 180
 181         SVILOG("[[[[[[[[[[[[[[vib_level changed!! new vib_level => %d\n", vib_level);
 182
 183         return;
 184 }
 185
 186 void sndstatus_cb(keynode_t *key, void* data)
 187 {
 188         sndstatus = vconf_keynode_get_int(key);
 189
 190         SVILOG("[[[[[[[[[[[[[[sndstatus changed!! new sndstatus => %d\n", sndstatus);
 191
 192         return;
 193 }
 194
 195 void vibstatus_cb(keynode_t *key, void* data)
 196 {
 197         vibstatus = vconf_keynode_get_bool(key);
 198
 199         SVILOG("[[[[[[[[[[[[[[vibstatus changed!! new vibstatus => %d\n", vibstatus);
 200
 201         return;
 202 }
 203
 204
 205 volume_type_t get_volume_type(sound_type sound_key)
 206 {
 207         volume_type_t type = VOLUME_TYPE_SYSTEM;
 208
 209         if (sound_key >= SVI_SND_OPERATION_POWERON && sound_key <= SVI_SND_OPERATION_SCRCAPTURE)
 210                 type = VOLUME_TYPE_SYSTEM;
 211         else
 212                 type = VOLUME_TYPE_SYSTEM;
 213
 214         return type;
 215 }
 216
 217 API int svi_init(int *handle)
 218 {
 219         int ret_vib = SVI_SUCCESS;
 220         int v_handle = 0;
 221
 222         /* Sound Init */
 223         if (vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &soundon) < 0)
 224                 SVILOG("vconf_get_int(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &soundon) ==> FAIL!!\n");
 225         SVILOG("vconf_get_int(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &soundon) ==> %d\n", soundon);
 226
 227         if (vconf_get_int("memory/Sound/SoundStatus", &sndstatus) < 0)
 228                 SVILOG("vconf_get_int(memory/Sound/SoundStatus, &sndstatus) ==> FAIL!!\n");
 229         SVILOG("vconf_get_int(memory/Sound/SoundStatus, &sndstatus) ==> %d\n", sndstatus);
 230
 231         vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, soundon_cb, NULL);
 232         vconf_notify_key_changed("memory/Sound/SoundStatus", sndstatus_cb, NULL);
 233
 234         /* Vibration Init */
 235         v_handle = device_haptic_open( DEV_IDX_0 , 0x01); // new haptic lib.
 236
 237         if (v_handle < 0)
 238         {
 239                 SVILOG("device_haptic_open(DEV_IDX_0) ==> FAIL!!\n");
 240                 ret_vib = SVI_ERROR;
 241         }
 242         else
 243         {
 244                 if (vconf_get_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vibstatus) < 0)    //check vibration status
 245                         SVILOG("vconf_get_int(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vibstatus) ==> FAIL!!\n");
 246                 SVILOG("vconf_get_int(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vibstatus) ==> %d\n", vibstatus);
 247
 248                 if (vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, &vib_level) < 0)    //check vib_level
 249                         SVILOG("vconf_get_int(VCONFKEY_SETAPPL_VIB_FEEDBACK_INT, &vib_level) ==> FAIL!!\n");
 250                 SVILOG("vconf_get_int(VCONFKEY_SETAPPL_VIB_FEEDBACK_INT, &vib_level) ==> %d\n", vib_level);
 251
 252                 vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibstatus_cb, NULL);
 253                 vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, vib_cb, NULL);
 254                 ret_vib = SVI_SUCCESS;
 255         }
 256
 257         if (ret_vib == SVI_ERROR) {
 258                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, soundon_cb);
 259                 vconf_ignore_key_changed("memory/Sound/SoundStatus", sndstatus_cb);
 260                 return SVI_ERROR;
 261         } else {
 262                 *handle = v_handle;
 263                 return SVI_SUCCESS;
 264         }
 265 }
 266
 267 API int svi_fini(int handle)
 268 {
 269         int ret_vib = SVI_SUCCESS;
 270
 271         vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, soundon_cb);
 272         vconf_ignore_key_changed("memory/Sound/SoundStatus", sndstatus_cb);
 273
 274         if (handle > 0) {
 275                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vibstatus_cb);
 276                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, vib_cb);
 277                 if (device_haptic_close(handle) < 0) {
 278                         ret_vib = SVI_ERROR;
 279                 } else {
 280                         ret_vib = SVI_SUCCESS;
 281                 }
 282         }
 283
 284         if ( ret_vib == SVI_ERROR) {
 285                 return SVI_ERROR;
 286         } else {
 287                 return SVI_SUCCESS;
 288         }
 289 }
 290
 291 API int svi_play_sound(int handle, sound_type sound_key)
 292 {
 293         int ret_snd = SVI_SUCCESS;
 294         struct stat buf;
 295         SVILOG("sound_key = %d\n", sound_key);
 296
 297         if (handle < 0) {
 298                 SVILOG("ERROR!! Please call svi_init() for sound init \n");
 299                 ret_snd = SVI_ERROR;
 300         }
 301         else
 302         {
 303                 if (sound_key > SVI_SND_NONE && sound_key <= SVI_SND_OPERATION_SCRCAPTURE)
 304                 {
 305                         SVILOG("soundon = %d, sndstatus = %d \n", soundon, sndstatus);
 306                         if (soundon != 0 && sndstatus == 0)
 307                         {
 308                                 if(stat(snd_file[sound_key], &buf)) { /*check file existence*/
 309                                         SVILOG("ERROR!! %s is not presents\n", snd_file[sound_key]);
 310                                         return SVI_ERROR;
 311                                 }
 312                                 if (mm_sound_play_keysound(snd_file[sound_key], get_volume_type(sound_key)) < 0)
 313                                 {
 314                                         SVILOG("ERROR!! mm_sound_play_keysound() returned error.\n");
 315                                         ret_snd = SVI_ERROR;
 316                                 }
 317                                 SVILOG("SND filename is %s\n", snd_file[sound_key]);
 318                         }
 319                 }
 320                 else if (sound_key != SVI_SND_NONE) {
 321                         ret_snd = SVI_ERROR;
 322                 }
 323         }
 324
 325         return ret_snd;
 326 }
 327
 328 API int svi_play_vib(int handle, vibration_type vibration_key)
 329 {
 330         int ret_vib = SVI_SUCCESS;
 331         struct stat buf;
 332
 333         SVILOG("vibration key - %d\n", vibration_key);
 334
 335         if (handle < 0) {
 336                 SVILOG("ERROR!! Please call svi_init() for vibration init \n");
 337                 ret_vib = SVI_ERROR;
 338         } else  {
 339                 if (vibration_key > SVI_VIB_NONE && vibration_key <= SVI_VIB_OPERATION_SHUTTER) {
 340                         if (vibration_key == SVI_VIB_OPERATION_FULLYCHARGED || vibration_key == SVI_VIB_OPERATION_LOTBATT) {
 341                                 SVILOG("vibration type is SVI_VIB_OPERATION_FULLYCHARGED or SVI_VIB_OPERATION_LOTBATT\n");
 342                                 if (device_haptic_play_file(handle, haptic_file[vibration_key], 1, 5) < 0) {
 343                                         SVILOG("ERROR!! device_haptic_play_file() returned error.\n");
 344                                         ret_vib = SVI_ERROR;
 345                                 }
 346                                 SVILOG("device_haptic_play_file(handle, vibration_key, 1, 5)\n");
 347                         } else {
 348                                 SVILOG("vibstatus = %d, vib_level = %d\n", vibstatus, vib_level);
 349                                 if (vibstatus != 0) {
 350                                         if(stat(haptic_file[vibration_key], &buf)) { /*check file existence*/
 351                                                 SVILOG("ERROR!! %s is not presents\n", haptic_file[vibration_key]);
 352                                                 return SVI_ERROR;
 353                                         }
 354                                         if (device_haptic_play_file(handle, haptic_file[vibration_key], 1, vib_level) < 0) {
 355                                                 SVILOG("ERROR!! device_haptic_play_file() returned error.\n");
 356                                                 ret_vib = SVI_ERROR;
 357                                         }
 358                                         SVILOG("device_haptic_play_file(handle, vibration_key, 1, %d)\n", vib_level);
 359                                 }
 360                         }
 361                 }
 362                 else if (vibration_key != SVI_VIB_NONE) {
 363                         ret_vib = SVI_ERROR;
 364                 }
 365         }
 366
 367         return ret_vib;
 368
 369 }
 370
 371 API int svi_play(int handle, vibration_type vibration_key, sound_type sound_key)
 372 {
 373         int ret_snd = svi_play_sound(handle, sound_key);
 374         int ret_vib = svi_play_vib(handle, vibration_key);
 375
 376         if (ret_snd == SVI_ERROR || ret_vib == SVI_ERROR) {
 377                 return SVI_ERROR;
 378         } else {
 379                 return SVI_SUCCESS;
 380         }
 381 }
 382
 383 API int svi_get_path(int svi_type, int svi_enum, char* buf, unsigned int bufLen)
 384 {
 385         vibration_type vib_enum_type = SVI_VIB_NONE;
 386         sound_type snd_enum_type = SVI_SND_NONE;
 387         unsigned int pathLen = 0;
 388
 389         SVILOG("starts\n");
 390
 391         if (buf == NULL || bufLen <= 0) {
 392                 SVILOG("ERROR!! invalid input parameters.\n");
 393                 return SVI_ERROR;
 394         }
 395
 396         if (!(svi_type == SVI_TYPE_SND || svi_type == SVI_TYPE_VIB)) {
 397                 SVILOG("ERROR!! invalid svi_type(%d).\n", svi_type);
 398                 return SVI_ERROR;
 399         }
 400
 401
 402         if (svi_type == SVI_TYPE_SND) {
 403                 snd_enum_type = (sound_type)svi_enum;
 404
 405                 if (snd_enum_type < SVI_SND_TOUCH_TOUCH1 || snd_enum_type> SVI_SND_OPERATION_SCRCAPTURE) {
 406                         SVILOG("ERROR! invalid svi_enum(%d)\n", snd_enum_type);
 407                         return SVI_ERROR;
 408                 }
 409                 pathLen = strlen(snd_file[snd_enum_type]);
 410                 if (pathLen <= 0) {
 411                         SVILOG("ERROR!! NULL path.\n");
 412                         return SVI_ERROR;
 413                 }
 414                 if (pathLen < bufLen) {
 415                         strncpy(buf, snd_file[snd_enum_type], bufLen);
 416                 } else {
 417                         SVILOG("ERROR!! Overflow.\n");
 418                         return SVI_ERROR;
 419                 }
 420         } else if (svi_type == SVI_TYPE_VIB) {
 421                 vib_enum_type = (vibration_type) svi_enum;
 422                 if (vib_enum_type < SVI_VIB_TOUCH_TOUCH || vib_enum_type > SVI_VIB_OPERATION_SHUTTER) {
 423                         SVILOG("ERROR! invalid svi_enum(%d)\n", vib_enum_type);
 424                         return SVI_ERROR;
 425                 }
 426                 pathLen = strlen(haptic_file[vib_enum_type]);
 427                 if (pathLen <= 0) {
 428                         SVILOG("ERROR!! NULL path.\n");
 429                         return SVI_ERROR;
 430                 }
 431                 if (pathLen < bufLen) {
 432                         strncpy(buf, haptic_file[vib_enum_type], bufLen);
 433                 } else {
 434                         SVILOG("ERROR!! Overflow.\n");
 435                         return SVI_ERROR;
 436                 }
 437         }
 438
 439         SVILOG("ends\n");
 440         return SVI_SUCCESS;
 441 }
 442