client/tts_setting.c

   1 /*
   2 *  Copyright (c) 2011-2014 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, 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, 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                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 115                 return TTS_SETTING_ERROR_NONE;
 116         }
 117
 118         int ret = tts_config_mgr_initialize(getpid());
 119         if (0 != ret) {
 120                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize config manager : %d", ret);
 121                 return __setting_convert_config_error_code(ret);
 122         }
 123
 124         ret = tts_config_mgr_set_callback(getpid(), __setting_config_engine_changed_cb, __setting_config_voice_changed_cb,
 125                 __setting_config_speech_rate_changed_cb, __setting_config_pitch_changed_cb, NULL);
 126         if (0 != ret) {
 127                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 128                 return __setting_convert_config_error_code(ret);
 129         }
 130
 131         g_state = TTS_SETTING_STATE_READY;
 132
 133         g_engine_changed_cb = NULL;
 134         g_engine_changed_user_data = NULL;
 135
 136         g_voice_changed_cb = NULL;
 137         g_voice_changed_user_data = NULL;
 138
 139         g_speed_changed_cb = NULL;
 140         g_speed_changed_user_data = NULL;
 141
 142         g_pitch_changed_cb = NULL;
 143         g_pitch_changed_user_data = NULL;
 144
 145         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 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());
 156
 157         g_state = TTS_SETTING_STATE_NONE;
 158
 159         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 160         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 161
 162         return TTS_SETTING_ERROR_NONE;
 163 }
 164
 165 bool __tts_config_mgr_get_engine_list(const char* engine_id, const char* engine_name, const char* setting, void* user_data)
 166 {
 167         if (NULL != g_engine_cb) {
 168                 return g_engine_cb(engine_id, engine_name, setting, user_data);
 169         }
 170
 171         return false;
 172 }
 173
 174 int tts_setting_foreach_supported_engines(tts_setting_supported_engine_cb callback, void* user_data)
 175 {
 176         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported engines");
 177
 178         if (TTS_SETTING_STATE_NONE == g_state) {
 179                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 180                 return TTS_SETTING_ERROR_INVALID_STATE;
 181         }
 182
 183         if (NULL == callback) {
 184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Callback is NULL");
 185                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 186         }
 187
 188         g_engine_cb = callback;
 189
 190         int ret = tts_config_mgr_get_engine_list(__tts_config_mgr_get_engine_list, user_data);
 191         if (0 != ret) {
 192                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 193         }
 194
 195         g_engine_cb = NULL;
 196
 197         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 198         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 199
 200         return __setting_convert_config_error_code(ret);
 201 }
 202
 203 int tts_setting_get_engine(char** engine_id)
 204 {
 205         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get current engine");
 206
 207         if (TTS_SETTING_STATE_NONE == g_state) {
 208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 209                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 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                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 218                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 219         }
 220
 221         int ret = tts_config_mgr_get_engine(engine_id);
 222         if (0 != ret) {
 223                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 224         } else {
 225                 SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get current engine");
 226         }
 227
 228         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 229         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 230
 231         return __setting_convert_config_error_code(ret);
 232 }
 233
 234 int tts_setting_set_engine(const char* engine_id)
 235 {
 236         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set current engine");
 237
 238         if (TTS_SETTING_STATE_NONE == g_state) {
 239                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 240                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 241                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 242                 return TTS_SETTING_ERROR_INVALID_STATE;
 243         }
 244
 245         if (NULL == engine_id) {
 246                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Engine id is NULL");
 247                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 248                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 249                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 250         }
 251
 252         int ret = tts_config_mgr_set_engine(engine_id);
 253         if (0 != ret) {
 254                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 255         } else {
 256                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set current engine : %s", engine_id);
 257         }
 258
 259         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 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         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 299
 300         return __setting_convert_config_error_code(ret);
 301 }
 302
 303 int tts_setting_get_voice(char** language, int* voice_type)
 304 {
 305         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 306
 307         if (TTS_SETTING_STATE_NONE == g_state) {
 308                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 309                 return TTS_SETTING_ERROR_INVALID_STATE;
 310         }
 311
 312         if (NULL == language || NULL == voice_type) {
 313                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 314                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 315         }
 316
 317         int ret = tts_config_mgr_get_voice(language, (int*)voice_type);
 318         if (0 != ret) {
 319                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 320         } else {
 321                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default voices : lang(%s) type(%d)", *language, *voice_type);
 322         }
 323
 324         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 325         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 326
 327         return __setting_convert_config_error_code(ret);
 328 }
 329
 330 int tts_setting_set_voice(const char* language, int voice_type)
 331 {
 332         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default voice");
 333
 334         if (TTS_SETTING_STATE_NONE == g_state) {
 335                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 336                 return TTS_SETTING_ERROR_INVALID_STATE;
 337         }
 338
 339         if (NULL == language) {
 340                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 341                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 342         }
 343
 344         if (voice_type < TTS_SETTING_VOICE_TYPE_MALE || TTS_SETTING_VOICE_TYPE_CHILD < voice_type) {
 345                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid voice type");
 346                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 347         }
 348
 349         int ret = tts_config_mgr_set_voice(language, (int)voice_type);
 350         if (0 != ret) {
 351                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 352         } else {
 353                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice : lang(%s) type(%d)", language, voice_type);
 354         }
 355
 356         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 357         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 358
 359         return __setting_convert_config_error_code(ret);
 360 }
 361
 362 int tts_setting_set_auto_voice(bool value)
 363 {
 364         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set auto voice");
 365
 366         if (TTS_SETTING_STATE_NONE == g_state) {
 367                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 368                 return TTS_SETTING_ERROR_INVALID_STATE;
 369         }
 370
 371         if (value != true && value != false) {
 372                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");
 373                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 374         }
 375
 376         int ret = tts_config_mgr_set_auto_voice(value);
 377         if (0 != ret) {
 378                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 379         } else {
 380                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set auto voice %s", value ? "on" : "off");
 381         }
 382
 383         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 384         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 385
 386         return __setting_convert_config_error_code(ret);
 387 }
 388
 389 int tts_setting_get_auto_voice(bool* value)
 390 {
 391         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get auto voice");
 392
 393         if (TTS_SETTING_STATE_NONE == g_state) {
 394                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 395                 return TTS_SETTING_ERROR_INVALID_STATE;
 396         }
 397
 398         if (NULL == value) {
 399                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 400                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 401         }
 402
 403         int ret = tts_config_mgr_get_auto_voice(value);
 404         if (0 != ret) {
 405                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 406         } else {
 407                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get auto voice : %d ", (int)*value);
 408         }
 409
 410         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 411         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 412
 413         return __setting_convert_config_error_code(ret);
 414 }
 415
 416 int tts_setting_get_speed_range(int* min, int* normal, int* max)
 417 {
 418         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get speed range");
 419
 420         if (TTS_SETTING_STATE_NONE == g_state) {
 421                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 422                 return TTS_SETTING_ERROR_INVALID_STATE;
 423         }
 424
 425         if (NULL == min || NULL == normal || NULL == max) {
 426                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 427                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 428         }
 429
 430         *min = TTS_SPEED_MIN;
 431         *normal = TTS_SPEED_NORMAL;
 432         *max = TTS_SPEED_MAX;
 433
 434         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get speed range : min(%d) normal(%d) max(%d)", *min, *normal, *max);
 435
 436         return TTS_SETTING_ERROR_NONE;
 437 }
 438
 439 int tts_setting_get_speed(int* speed)
 440 {
 441         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default speed");
 442
 443         if (TTS_SETTING_STATE_NONE == g_state) {
 444                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 445                 return TTS_SETTING_ERROR_INVALID_STATE;
 446         }
 447
 448         if (NULL == speed) {
 449                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Param is NULL");
 450                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         int temp;
 454         temp = 0;
 455
 456         int ret = tts_config_mgr_get_speech_rate(&temp);
 457         if (0 != ret) {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 459         } else {
 460                 /* Copy value */
 461                 *speed = temp;
 462                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default speed : %d ", *speed);
 463         }
 464
 465         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 466         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 467
 468         return __setting_convert_config_error_code(ret);
 469 }
 470
 471 int tts_setting_set_speed(int speed)
 472 {
 473         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default speed");
 474
 475         if (TTS_SETTING_STATE_NONE == g_state) {
 476                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 477                 return TTS_SETTING_ERROR_INVALID_STATE;
 478         }
 479
 480         if (TTS_SPEED_MIN > speed || speed > TTS_SPEED_MAX) {
 481                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid speed");
 482                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 483         }
 484
 485         int ret = tts_config_mgr_set_speech_rate(speed);
 486         if (0 != ret) {
 487                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 488         } else {
 489                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default speed, %d", speed);
 490         }
 491
 492         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 493         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 494
 495         return __setting_convert_config_error_code(ret);
 496 }
 497
 498 int tts_setting_get_pitch_range(int* min, int* normal, int* max)
 499 {
 500         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get speed range");
 501
 502         if (TTS_SETTING_STATE_NONE == g_state) {
 503                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 504                 return TTS_SETTING_ERROR_INVALID_STATE;
 505         }
 506
 507         if (NULL == min || NULL == normal || NULL == max) {
 508                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 509                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 510         }
 511
 512         *min = TTS_PITCH_MIN;
 513         *normal = TTS_PITCH_NORMAL;
 514         *max = TTS_PITCH_MAX;
 515
 516         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get pitch range : min(%d) normal(%d) max(%d)", *min, *normal, *max);
 517
 518         return TTS_SETTING_ERROR_NONE;
 519 }
 520
 521 int tts_setting_set_pitch(int pitch)
 522 {
 523         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set default pitch");
 524
 525         if (TTS_SETTING_STATE_NONE == g_state) {
 526                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 527                 return TTS_SETTING_ERROR_INVALID_STATE;
 528         }
 529
 530         if (TTS_PITCH_MIN > pitch || pitch > TTS_PITCH_MAX) {
 531                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid pitch");
 532                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 533         }
 534
 535         int ret = tts_config_mgr_set_pitch(pitch);
 536         if (0 != ret) {
 537                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 538         } else {
 539                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default pitch, %d", pitch);
 540         }
 541
 542         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 543         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 544
 545         return __setting_convert_config_error_code(ret);
 546 }
 547
 548 int tts_setting_get_pitch(int* pitch)
 549 {
 550         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default pitch");
 551
 552         if (TTS_SETTING_STATE_NONE == g_state) {
 553                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Not initialized");
 554                 return TTS_SETTING_ERROR_INVALID_STATE;
 555         }
 556
 557         if (NULL == pitch) {
 558                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is NULL");
 559                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         int temp;
 563         temp = 0;
 564
 565         int ret = tts_config_mgr_get_pitch(&temp);
 566         if (0 != ret) {
 567                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 568         } else {
 569                 /* Copy value */
 570                 *pitch = temp;
 571                 SECURE_SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Get default pitch : %d ", *pitch);
 572         }
 573
 574         return __setting_convert_config_error_code(ret);
 575 }
 576
 577 int tts_setting_set_engine_changed_cb(tts_setting_engine_changed_cb callback, void* user_data)
 578 {
 579         if (NULL == callback) {
 580                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 581                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 582         }
 583
 584         g_engine_changed_cb = callback;
 585         g_engine_changed_user_data = user_data;
 586
 587         return TTS_SETTING_ERROR_NONE;
 588 }
 589
 590 int tts_setting_unset_engine_changed_cb()
 591 {
 592         g_engine_changed_cb = NULL;
 593         g_engine_changed_user_data = NULL;
 594
 595         return TTS_SETTING_ERROR_NONE;
 596 }
 597
 598 int tts_setting_set_voice_changed_cb(tts_setting_voice_changed_cb callback, void* user_data)
 599 {
 600         if (NULL == callback) {
 601                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 602                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         g_voice_changed_cb = callback;
 606         g_voice_changed_user_data = user_data;
 607
 608         return TTS_SETTING_ERROR_NONE;
 609 }
 610
 611 int tts_setting_unset_voice_changed_cb()
 612 {
 613         g_voice_changed_cb = NULL;
 614         g_voice_changed_user_data = NULL;
 615
 616         return TTS_SETTING_ERROR_NONE;
 617 }
 618
 619 int tts_setting_set_speed_changed_cb(tts_setting_speed_changed_cb callback, void* user_data)
 620 {
 621         if (NULL == callback) {
 622                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 623                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 624         }
 625
 626         g_speed_changed_cb = callback;
 627         g_speed_changed_user_data = user_data;
 628
 629         return TTS_SETTING_ERROR_NONE;
 630 }
 631
 632 int tts_setting_unset_speed_changed_cb()
 633 {
 634         g_speed_changed_cb = NULL;
 635         g_speed_changed_user_data = NULL;
 636
 637         return TTS_SETTING_ERROR_NONE;
 638 }
 639
 640
 641 int tts_setting_set_pitch_changed_cb(tts_setting_pitch_changed_cb callback, void* user_data)
 642 {
 643         if (NULL == callback) {
 644                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input param is NULL");
 645                 return TTS_SETTING_ERROR_INVALID_PARAMETER;
 646         }
 647
 648         g_pitch_changed_cb = callback;
 649         g_pitch_changed_user_data = user_data;
 650
 651         return TTS_SETTING_ERROR_NONE;
 652 }
 653
 654 int tts_setting_unset_pitch_changed_cb()
 655 {
 656         g_pitch_changed_cb = NULL;
 657         g_pitch_changed_user_data = NULL;
 658
 659         return TTS_SETTING_ERROR_NONE;
 660 }