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