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