client/tts_setting.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <dirent.h>
  15 #include <Ecore.h>
  16 #include <sys/wait.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19
  20 #include "tts_config_mgr.h"
  21 #include "tts_main.h"
  22 #include "tts_setting.h"
  23
  24 /**
  25 * @brief Enumerations of setting state.
  26 */
  27 typedef enum {
  28         TTS_SETTING_STATE_NONE = 0,
  29         TTS_SETTING_STATE_READY
  30 } tts_setting_state_e;
  31
  32
  33 static tts_setting_state_e g_state = TTS_SETTING_STATE_NONE;
  34
  35 static tts_setting_supported_engine_cb g_engine_cb;
  36
  37 static tts_setting_engine_changed_cb g_engine_changed_cb;
  38 static void* g_engine_changed_user_data;
  39
  40 static tts_setting_voice_changed_cb g_voice_changed_cb;
  41 static void* g_voice_changed_user_data;
  42
  43 static tts_setting_speed_changed_cb g_speed_changed_cb;
  44 static void* g_speed_changed_user_data;
  45
  46 static tts_setting_pitch_changed_cb g_pitch_changed_cb;
  47 static void* g_pitch_changed_user_data;
  48
  49 static tts_setting_background_volume_ratio_changed_cb g_bg_volume_ratio_changed_cb;
  50 static void* g_bg_volume_ratio_changed_user_data;
  51
  52
  53 static int __setting_convert_config_error_code(tts_config_error_e code)
  54 {
  55         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_SETTING_ERROR_NONE;
  56         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_SETTING_ERROR_OUT_OF_MEMORY;
  57         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_SETTING_ERROR_IO_ERROR;
  58         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_SETTING_ERROR_INVALID_PARAMETER;
  59         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_SETTING_ERROR_INVALID_STATE;
  60         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_SETTING_ERROR_INVALID_VOICE;
  61         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_SETTING_ERROR_ENGINE_NOT_FOUND;
  62         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_SETTING_ERROR_OPERATION_FAILED;
  63         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_SETTING_ERROR_NOT_SUPPORTED_FEATURE;
  64
  65         return TTS_SETTING_ERROR_NONE;
  66 }
  67
  68 void __setting_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, int voice_type, bool auto_voice, bool need_credential, void* user_data)
  69 {
  70         SLOG(LOG_DEBUG, TAG_TTSC, "Engine changed : engine(%s) setting(%s) lang(%s) type(%d)",
  71                  engine_id, setting, language, voice_type);
  72
  73         if (NULL != g_engine_changed_cb)
  74                 g_engine_changed_cb(engine_id, g_engine_changed_user_data);
  75
  76         if (NULL != g_voice_changed_cb)
  77                 g_voice_changed_cb(language, voice_type, auto_voice, g_voice_changed_user_data);
  78 }
  79
  80 void __setting_config_voice_changed_cb(const char* before_language, int before_type, const char* language, int voice_type, bool auto_voice, void* user_data)
  81 {
  82         SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : lang(%s) type(%d) auto(%s)", language, voice_type, auto_voice ? "on" : "off");
  83
  84         if (NULL != g_voice_changed_cb)
  85                 g_voice_changed_cb(language, voice_type, auto_voice, g_voice_changed_user_data);
  86 }
  87
  88 void __setting_config_speech_rate_changed_cb(int value, void* user_data)
  89 {
  90         SLOG(LOG_DEBUG, TAG_TTSC, "Speech rate : %d", value);
  91
  92         if (NULL != g_speed_changed_cb)
  93                 g_speed_changed_cb(value, g_speed_changed_user_data);
  94 }
  95
  96 void __setting_config_pitch_changed_cb(int value, void* user_data)
  97 {
  98         SLOG(LOG_DEBUG, TAG_TTSC, "Pitch : %d", value);
  99
 100         if (NULL != g_pitch_changed_cb)
 101                 g_pitch_changed_cb(value, g_pitch_changed_user_data);
 102 }
 103
 104 void __setting_config_bg_volume_ratio_changed_cb(double value, void* user_data)
 105 {
 106         SLOG(LOG_DEBUG, TAG_TTSC, "Rratio : %lf", value);
 107
 108         if (NULL != g_bg_volume_ratio_changed_cb)
 109                 g_bg_volume_ratio_changed_cb(value, g_bg_volume_ratio_changed_user_data);
 110 }
 111
 112 int tts_setting_initialize()
 113 {
 114         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Initialize TTS Setting");
 115
 116         if (TTS_SETTING_STATE_READY == g_state) {
 117                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] TTS Setting has already been initialized.");
 118                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 119                 return TTS_SETTING_ERROR_NONE;
 120         }
 121
 122         int ret = tts_config_mgr_initialize(getpid(), TTS_CONFIG_CLIENT_TYPE_SETTING);
 123         if (0 != ret) {
 124                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize config manager : %d", ret);
 125                 return __setting_convert_config_error_code(ret);
 126         }
 127
 128         ret = tts_config_mgr_set_callback(getpid(), __setting_config_engine_changed_cb, __setting_config_voice_changed_cb,
 129                                                                           __setting_config_speech_rate_changed_cb, __setting_config_pitch_changed_cb, __setting_config_bg_volume_ratio_changed_cb, NULL);
 130         if (0 != ret) {
 131                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 132                 return __setting_convert_config_error_code(ret);
 133         }
 134
 135         g_state = TTS_SETTING_STATE_READY;
 136
 137         g_engine_changed_cb = NULL;
 138         g_engine_changed_user_data = NULL;
 139
 140         g_voice_changed_cb = NULL;
 141         g_voice_changed_user_data = NULL;
 142
 143         g_speed_changed_cb = NULL;
 144         g_speed_changed_user_data = NULL;
 145
 146         g_pitch_changed_cb = NULL;
 147         g_pitch_changed_user_data = NULL;
 148
 149         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 150
 151         return TTS_SETTING_ERROR_NONE;
 152 }
 153
 154 int tts_setting_finalize()
 155 {
 156         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Finalize TTS Setting");
 157
 158         tts_config_mgr_finalize(getpid(), TTS_CONFIG_CLIENT_TYPE_SETTING);
 159
 160         g_state = TTS_SETTING_STATE_NONE;
 161
 162         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 163
 164         return TTS_SETTING_ERROR_NONE;
 165 }
 166
 167 bool __tts_config_mgr_get_engine_list(const char* engine_id, const char* engine_name, const char* setting, void* user_data)
 168 {
 169         if (NULL != g_engine_cb) {
 170                 return g_engine_cb(engine_id, engine_name, setting, user_data);
 171         }
 172
 173         return false;
 174 }
 175
 176 int tts_setting_foreach_supported_engines(tts_setting_supported_engine_cb callback, void* user_data)
 177 {
 178         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported engines");
 179
 180         if (TTS_SETTING_STATE_NONE == g_state) {
 181                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 182                 return TTS_SETTING_ERROR_INVALID_STATE;
 183         }
 184
 185         if (NULL == callback) {
 186                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Callback is NULL");
 187                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 188         }
 189
 190         g_engine_cb = callback;
 191
 192         int ret = tts_config_mgr_get_engine_list(__tts_config_mgr_get_engine_list, user_data);
 193         if (0 != ret) {
 194                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 195         }
 196
 197         g_engine_cb = NULL;
 198
 199         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 200
 201         return __setting_convert_config_error_code(ret);
 202 }
 203
 204 int tts_setting_get_engine(char** engine_id)
 205 {
 206         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get current engine");
 207
 208         if (TTS_SETTING_STATE_NONE == g_state) {
 209                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 210                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 211                 return TTS_SETTING_ERROR_INVALID_STATE;
 212         }
 213
 214         if (NULL == engine_id) {
 215                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 216                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 217                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 218         }
 219
 220         int ret = tts_config_mgr_get_engine(engine_id);
 221         if (0 != ret) {
 222                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 223         } else {
 224                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get current engine");
 225         }
 226
 227         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 228
 229         return __setting_convert_config_error_code(ret);
 230 }
 231
 232 int tts_setting_set_engine(const char* engine_id)
 233 {
 234         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set current engine");
 235
 236         if (TTS_SETTING_STATE_NONE == g_state) {
 237                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 238                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 239                 return TTS_SETTING_ERROR_INVALID_STATE;
 240         }
 241
 242         if (NULL == engine_id) {
 243                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 244                 SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 245                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 246         }
 247
 248         int ret = tts_config_mgr_set_engine(engine_id);
 249         if (0 != ret) {
 250                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 251         } else {
 252                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set current engine : %s", engine_id);
 253         }
 254
 255         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 256
 257         return __setting_convert_config_error_code(ret);
 258 }
 259
 260 int tts_setting_foreach_supported_voices(tts_setting_supported_voice_cb callback, void* user_data)
 261 {
 262         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 263
 264         if (TTS_SETTING_STATE_NONE == g_state) {
 265                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 266                 return TTS_SETTING_ERROR_INVALID_STATE;
 267         }
 268
 269         if (NULL == callback) {
 270                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 271                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 272         }
 273
 274         char* current_engine = NULL;
 275         int ret = tts_config_mgr_get_engine(&current_engine);
 276         if (0 != ret) {
 277                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 278                 return TTS_SETTING_ERROR_OPERATION_FAILED;
 279         }
 280
 281         ret = tts_config_mgr_get_voice_list(current_engine, (tts_config_supported_voice_cb)callback, user_data);
 282
 283         if (NULL != current_engine)
 284                 free(current_engine);
 285
 286         if (0 != ret) {
 287                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 288         } else {
 289                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Foreach supported voices");
 290         }
 291
 292         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 293
 294         return __setting_convert_config_error_code(ret);
 295 }
 296
 297 int tts_setting_get_voice(char** language, int* voice_type)
 298 {
 299         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 300
 301         if (TTS_SETTING_STATE_NONE == g_state) {
 302                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 303                 return TTS_SETTING_ERROR_INVALID_STATE;
 304         }
 305
 306         if (NULL == language || NULL == voice_type) {
 307                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 308                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 309         }
 310
 311         int ret = tts_config_mgr_get_voice(language, (int*)voice_type);
 312         if (0 != ret) {
 313                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 314         } else {
 315                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default voices : lang(%s) type(%d)", *language, *voice_type);
 316         }
 317
 318         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 319
 320         return __setting_convert_config_error_code(ret);
 321 }
 322
 323 int tts_setting_set_voice(const char* language, int voice_type)
 324 {
 325         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set default voice");
 326
 327         if (TTS_SETTING_STATE_NONE == g_state) {
 328                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 329                 return TTS_SETTING_ERROR_INVALID_STATE;
 330         }
 331
 332         if (NULL == language) {
 333                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 334                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 335         }
 336
 337         if (voice_type < TTS_SETTING_VOICE_TYPE_MALE || TTS_SETTING_VOICE_TYPE_CHILD < voice_type) {
 338                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid voice type");
 339                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 340         }
 341
 342         int ret = tts_config_mgr_set_voice(language, (int)voice_type);
 343         if (0 != ret) {
 344                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 345         } else {
 346                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice : lang(%s) type(%d)", language, voice_type);
 347         }
 348
 349         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 350
 351         return __setting_convert_config_error_code(ret);
 352 }
 353
 354 int tts_setting_set_auto_voice(bool value)
 355 {
 356         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set auto voice");
 357
 358         if (TTS_SETTING_STATE_NONE == g_state) {
 359                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 360                 return TTS_SETTING_ERROR_INVALID_STATE;
 361         }
 362
 363         if (value != true && value != false) {
 364                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");
 365                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 366         }
 367
 368         int ret = tts_config_mgr_set_auto_voice(value);
 369         if (0 != ret) {
 370                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 371         } else {
 372                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set auto voice %s", value ? "on" : "off");
 373         }
 374
 375         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 376
 377         return __setting_convert_config_error_code(ret);
 378 }
 379
 380 int tts_setting_get_auto_voice(bool* value)
 381 {
 382         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get auto voice");
 383
 384         if (TTS_SETTING_STATE_NONE == g_state) {
 385                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 386                 return TTS_SETTING_ERROR_INVALID_STATE;
 387         }
 388
 389         if (NULL == value) {
 390                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 391                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 392         }
 393
 394         int ret = tts_config_mgr_get_auto_voice(value);
 395         if (0 != ret) {
 396                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 397         } else {
 398                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get auto voice : %d ", (int)*value);
 399         }
 400
 401         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 402
 403         return __setting_convert_config_error_code(ret);
 404 }
 405
 406 int tts_setting_get_speed_range(int* min, int* normal, int* max)
 407 {
 408         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get speed range");
 409
 410         if (TTS_SETTING_STATE_NONE == g_state) {
 411                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 412                 return TTS_SETTING_ERROR_INVALID_STATE;
 413         }
 414
 415         if (NULL == min || NULL == normal || NULL == max) {
 416                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 417                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         *min = TTS_SPEED_MIN;
 421         *normal = TTS_SPEED_NORMAL;
 422         *max = TTS_SPEED_MAX;
 423
 424         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get speed range : min(%d) normal(%d) max(%d)", *min, *normal, *max);
 425
 426         return TTS_SETTING_ERROR_NONE;
 427 }
 428
 429 int tts_setting_get_speed(int* speed)
 430 {
 431         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default speed");
 432
 433         if (TTS_SETTING_STATE_NONE == g_state) {
 434                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 435                 return TTS_SETTING_ERROR_INVALID_STATE;
 436         }
 437
 438         if (NULL == speed) {
 439                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 440                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 441         }
 442
 443         int temp;
 444         temp = 0;
 445
 446         int ret = tts_config_mgr_get_speech_rate(&temp);
 447         if (0 != ret) {
 448                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 449         } else {
 450                 /* Copy value */
 451                 *speed = temp;
 452                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default speed : %d ", *speed);
 453         }
 454
 455         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 456
 457         return __setting_convert_config_error_code(ret);
 458 }
 459
 460 int tts_setting_set_speed(int speed)
 461 {
 462         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set default speed");
 463
 464         if (TTS_SETTING_STATE_NONE == g_state) {
 465                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 466                 return TTS_SETTING_ERROR_INVALID_STATE;
 467         }
 468
 469         if (TTS_SPEED_MIN > speed || speed > TTS_SPEED_MAX) {
 470                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid speed");
 471                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 472         }
 473
 474         int ret = tts_config_mgr_set_speech_rate(speed);
 475         if (0 != ret) {
 476                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 477         } else {
 478                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default speed, %d", speed);
 479         }
 480
 481         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 482
 483         return __setting_convert_config_error_code(ret);
 484 }
 485
 486 int tts_setting_get_pitch_range(int* min, int* normal, int* max)
 487 {
 488         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get speed range");
 489
 490         if (TTS_SETTING_STATE_NONE == g_state) {
 491                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 492                 return TTS_SETTING_ERROR_INVALID_STATE;
 493         }
 494
 495         if (NULL == min || NULL == normal || NULL == max) {
 496                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 497                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 498         }
 499
 500         *min = TTS_PITCH_MIN;
 501         *normal = TTS_PITCH_NORMAL;
 502         *max = TTS_PITCH_MAX;
 503
 504         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get pitch range : min(%d) normal(%d) max(%d)", *min, *normal, *max);
 505
 506         return TTS_SETTING_ERROR_NONE;
 507 }
 508
 509 int tts_setting_set_pitch(int pitch)
 510 {
 511         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set default pitch");
 512
 513         if (TTS_SETTING_STATE_NONE == g_state) {
 514                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 515                 return TTS_SETTING_ERROR_INVALID_STATE;
 516         }
 517
 518         if (TTS_PITCH_MIN > pitch || pitch > TTS_PITCH_MAX) {
 519                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid pitch");
 520                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 521         }
 522
 523         int ret = tts_config_mgr_set_pitch(pitch);
 524         if (0 != ret) {
 525                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 526         } else {
 527                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default pitch, %d", pitch);
 528         }
 529
 530         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 531
 532         return __setting_convert_config_error_code(ret);
 533 }
 534
 535 int tts_setting_get_background_volume_ratio(double *ratio)
 536 {
 537         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get background ratio");
 538
 539         if (TTS_SETTING_STATE_NONE == g_state) {
 540                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 541                 return TTS_SETTING_ERROR_INVALID_STATE;
 542         }
 543
 544         if (NULL == ratio) {
 545                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 546                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         double temp;
 550         temp = 0;
 551
 552         int ret = tts_config_mgr_get_bg_volume_ratio(&temp);
 553         if (0 != ret) {
 554                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 555         } else {
 556                 /* Copy value */
 557                 *ratio = temp;
 558                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get bg volume duration : %lf", *ratio);
 559         }
 560
 561         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 562
 563         return __setting_convert_config_error_code(ret);
 564 }
 565
 566 int tts_setting_set_background_volume_ratio(double ratio)
 567 {
 568         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Set bg volume duration");
 569
 570         if (TTS_SETTING_STATE_NONE == g_state) {
 571                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 572                 return TTS_SETTING_ERROR_INVALID_STATE;
 573         }
 574
 575         if (0.0 > ratio || ratio > 1.0) {
 576                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid bg volume ratio(%lf)", ratio);
 577                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 578         }
 579
 580         int ret = tts_config_mgr_set_bg_volume_ratio(ratio);
 581         if (0 != ret) {
 582                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 583         } else {
 584                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set bg volume ratio : %lf", ratio);
 585         }
 586
 587         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 588
 589         return __setting_convert_config_error_code(ret);
 590 }
 591
 592 int tts_setting_get_pitch(int* pitch)
 593 {
 594         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default pitch");
 595
 596         if (TTS_SETTING_STATE_NONE == g_state) {
 597                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 598                 return TTS_SETTING_ERROR_INVALID_STATE;
 599         }
 600
 601         if (NULL == pitch) {
 602                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 603                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 604         }
 605
 606         int temp;
 607         temp = 0;
 608
 609         int ret = tts_config_mgr_get_pitch(&temp);
 610         if (0 != ret) {
 611                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 612         } else {
 613                 /* Copy value */
 614                 *pitch = temp;
 615                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default pitch : %d ", *pitch);
 616         }
 617
 618         return __setting_convert_config_error_code(ret);
 619 }
 620
 621 int tts_setting_set_engine_changed_cb(tts_setting_engine_changed_cb callback, void* user_data)
 622 {
 623         if (NULL == callback) {
 624                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 625                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 626         }
 627
 628         g_engine_changed_cb = callback;
 629         g_engine_changed_user_data = user_data;
 630
 631         return TTS_SETTING_ERROR_NONE;
 632 }
 633
 634 int tts_setting_unset_engine_changed_cb()
 635 {
 636         g_engine_changed_cb = NULL;
 637         g_engine_changed_user_data = NULL;
 638
 639         return TTS_SETTING_ERROR_NONE;
 640 }
 641
 642 int tts_setting_set_voice_changed_cb(tts_setting_voice_changed_cb callback, void* user_data)
 643 {
 644         if (NULL == callback) {
 645                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 646                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 647         }
 648
 649         g_voice_changed_cb = callback;
 650         g_voice_changed_user_data = user_data;
 651
 652         return TTS_SETTING_ERROR_NONE;
 653 }
 654
 655 int tts_setting_unset_voice_changed_cb()
 656 {
 657         g_voice_changed_cb = NULL;
 658         g_voice_changed_user_data = NULL;
 659
 660         return TTS_SETTING_ERROR_NONE;
 661 }
 662
 663 int tts_setting_set_speed_changed_cb(tts_setting_speed_changed_cb callback, void* user_data)
 664 {
 665         if (NULL == callback) {
 666                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 667                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 668         }
 669
 670         g_speed_changed_cb = callback;
 671         g_speed_changed_user_data = user_data;
 672
 673         return TTS_SETTING_ERROR_NONE;
 674 }
 675
 676 int tts_setting_unset_speed_changed_cb()
 677 {
 678         g_speed_changed_cb = NULL;
 679         g_speed_changed_user_data = NULL;
 680
 681         return TTS_SETTING_ERROR_NONE;
 682 }
 683
 684
 685 int tts_setting_set_pitch_changed_cb(tts_setting_pitch_changed_cb callback, void* user_data)
 686 {
 687         if (NULL == callback) {
 688                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 689                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 690         }
 691
 692         g_pitch_changed_cb = callback;
 693         g_pitch_changed_user_data = user_data;
 694
 695         return TTS_SETTING_ERROR_NONE;
 696 }
 697
 698 int tts_setting_unset_pitch_changed_cb()
 699 {
 700         g_pitch_changed_cb = NULL;
 701         g_pitch_changed_user_data = NULL;
 702
 703         return TTS_SETTING_ERROR_NONE;
 704 }
 705
 706
 707 int tts_setting_set_background_volume_ratio_changed_cb(tts_setting_background_volume_ratio_changed_cb callback, void* user_data)
 708 {
 709         if (NULL == callback) {
 710                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 711                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 712         }
 713
 714         g_bg_volume_ratio_changed_cb = callback;
 715         g_bg_volume_ratio_changed_user_data = user_data;
 716
 717         return TTS_SETTING_ERROR_NONE;
 718 }
 719
 720 int tts_setting_unset_background_volume_ratio_changed_cb()
 721 {
 722         g_bg_volume_ratio_changed_cb = NULL;
 723         g_bg_volume_ratio_changed_user_data = NULL;
 724
 725         return TTS_SETTING_ERROR_NONE;
 726 }