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