client/stt.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 <aul.h>
  15 #include <dirent.h>
  16 #include <Ecore.h>
  17 #include <fcntl.h>
  18 #include <pthread.h>
  19 #include <sys/stat.h>
  20 #include <sys/types.h>
  21 #include <sys/wait.h>
  22 #include <system_info.h>
  23 #include <unistd.h>
  24
  25 #include "stt.h"
  26 #include "stt_client.h"
  27 #include "stt_dbus.h"
  28 #include "stt_config_mgr.h"
  29 #include "stt_main.h"
  30
  31
  32 static void __stt_notify_state_changed(void *data);
  33 static Eina_Bool __stt_notify_error(void *data);
  34
  35 static Ecore_Timer* g_connect_timer = NULL;
  36 static float g_volume_db = 0;
  37
  38 static int g_feature_enabled = -1;
  39
  40 static bool g_err_callback_status = false;
  41
  42 const char* stt_tag()
  43 {
  44         return "sttc";
  45 }
  46
  47 static int __stt_get_feature_enabled()
  48 {
  49         if (0 == g_feature_enabled) {
  50                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
  51                 return STT_ERROR_NOT_SUPPORTED;
  52         } else if (-1 == g_feature_enabled) {
  53                 bool stt_supported = false;
  54                 bool mic_supported = false;
  55                 if (0 == system_info_get_platform_bool(STT_FEATURE_PATH, &stt_supported)) {
  56                         if (0 == system_info_get_platform_bool(STT_MIC_FEATURE_PATH, &mic_supported)) {
  57                                 if (false == stt_supported || false == mic_supported) {
  58                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] STT NOT supported");
  59                                         g_feature_enabled = 0;
  60                                         return STT_ERROR_NOT_SUPPORTED;
  61                                 }
  62
  63                                 g_feature_enabled = 1;
  64                         } else {
  65                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
  66                                 return STT_ERROR_NOT_SUPPORTED;
  67                         }
  68                 } else {
  69                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get feature value");
  70                         return STT_ERROR_NOT_SUPPORTED;
  71                 }
  72         }
  73
  74         return 0;
  75 }
  76
  77 static const char* __stt_get_error_code(stt_error_e err)
  78 {
  79         switch (err) {
  80         case STT_ERROR_NONE:                    return "STT_ERROR_NONE";
  81         case STT_ERROR_OUT_OF_MEMORY:           return "STT_ERROR_OUT_OF_MEMORY";
  82         case STT_ERROR_IO_ERROR:                return "STT_ERROR_IO_ERROR";
  83         case STT_ERROR_INVALID_PARAMETER:       return "STT_ERROR_INVALID_PARAMETER";
  84         case STT_ERROR_TIMED_OUT:               return "STT_ERROR_TIMED_OUT";
  85         case STT_ERROR_RECORDER_BUSY:           return "STT_ERROR_RECORDER_BUSY";
  86         case STT_ERROR_OUT_OF_NETWORK:          return "STT_ERROR_OUT_OF_NETWORK";
  87         case STT_ERROR_PERMISSION_DENIED:       return "STT_ERROR_PERMISSION_DENIED";
  88         case STT_ERROR_NOT_SUPPORTED:           return "STT_ERROR_NOT_SUPPORTED";
  89         case STT_ERROR_INVALID_STATE:           return "STT_ERROR_INVALID_STATE";
  90         case STT_ERROR_INVALID_LANGUAGE:        return "STT_ERROR_INVALID_LANGUAGE";
  91         case STT_ERROR_ENGINE_NOT_FOUND:        return "STT_ERROR_ENGINE_NOT_FOUND";
  92         case STT_ERROR_OPERATION_FAILED:        return "STT_ERROR_OPERATION_FAILED";
  93         case STT_ERROR_NOT_SUPPORTED_FEATURE:   return "STT_ERROR_NOT_SUPPORTED_FEATURE";
  94         default:
  95                 return "Invalid error code";
  96         }
  97 }
  98
  99 static int __stt_convert_config_error_code(stt_config_error_e code)
 100 {
 101         if (code == STT_CONFIG_ERROR_NONE)                      return STT_ERROR_NONE;
 102         if (code == STT_CONFIG_ERROR_OUT_OF_MEMORY)             return STT_ERROR_OUT_OF_MEMORY;
 103         if (code == STT_CONFIG_ERROR_IO_ERROR)                  return STT_ERROR_IO_ERROR;
 104         if (code == STT_CONFIG_ERROR_INVALID_PARAMETER)         return STT_ERROR_INVALID_PARAMETER;
 105         if (code == STT_CONFIG_ERROR_PERMISSION_DENIED)         return STT_ERROR_PERMISSION_DENIED;
 106         if (code == STT_CONFIG_ERROR_NOT_SUPPORTED)             return STT_ERROR_NOT_SUPPORTED;
 107         if (code == STT_CONFIG_ERROR_INVALID_STATE)             return STT_ERROR_INVALID_STATE;
 108         if (code == STT_CONFIG_ERROR_INVALID_LANGUAGE)          return STT_ERROR_INVALID_LANGUAGE;
 109         if (code == STT_CONFIG_ERROR_ENGINE_NOT_FOUND)          return STT_ERROR_ENGINE_NOT_FOUND;
 110         if (code == STT_CONFIG_ERROR_OPERATION_FAILED)          return STT_ERROR_OPERATION_FAILED;
 111
 112         return code;
 113 }
 114
 115 void __stt_config_lang_changed_cb(const char* before_language, const char* current_language, void* user_data)
 116 {
 117         SLOG(LOG_DEBUG, TAG_STTC, "Language changed : Before lang(%s) Current lang(%s)",
 118                 before_language, current_language);
 119
 120         if (0 == strcmp(before_language, current_language)) {
 121                 return;
 122         }
 123
 124         GList* client_list = NULL;
 125         client_list = stt_client_get_client_list();
 126
 127         GList *iter = NULL;
 128         stt_client_s *data = NULL;
 129
 130         if (g_list_length(client_list) > 0) {
 131                 /* Get a first item */
 132                 iter = g_list_first(client_list);
 133
 134                 while (NULL != iter) {
 135                         data = iter->data;
 136                         if (NULL != data->default_lang_changed_cb) {
 137                                 SLOG(LOG_DEBUG, TAG_STTC, "Call default language changed callback : uid(%d)", data->uid);
 138                                 data->default_lang_changed_cb(data->stt, before_language, current_language,
 139                                         data->default_lang_changed_user_data);
 140                         }
 141
 142                         /* Next item */
 143                         iter = g_list_next(iter);
 144                 }
 145         }
 146
 147         return;
 148 }
 149
 150 void __stt_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, bool support_silence, bool need_credential, void* user_data)
 151 {
 152         stt_h stt = (stt_h)user_data;
 153
 154         stt_client_s* client = stt_client_get(stt);
 155         if (NULL == client) {
 156                 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
 157                 return;
 158         }
 159
 160         if (NULL != engine_id)  SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id);
 161         if (NULL != setting)    SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting);
 162         if (NULL != language)   SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language);
 163         SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need");
 164
 165         /* call callback function */
 166         if (NULL != client->engine_changed_cb) {
 167                 client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data);
 168         } else {
 169                 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
 170         }
 171         return;
 172 }
 173
 174 int stt_create(stt_h* stt)
 175 {
 176         if (0 != __stt_get_feature_enabled()) {
 177                 return STT_ERROR_NOT_SUPPORTED;
 178         }
 179
 180         SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT");
 181
 182         if (NULL == stt) {
 183                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is null");
 184                 return STT_ERROR_INVALID_PARAMETER;
 185         }
 186
 187         if (0 == stt_client_get_size()) {
 188                 if (0 != stt_dbus_open_connection()) {
 189                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to open connection");
 190                         return STT_ERROR_OPERATION_FAILED;
 191                 }
 192         }
 193
 194         if (0 != stt_client_new(stt)) {
 195                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client!");
 196                 return STT_ERROR_OUT_OF_MEMORY;
 197         }
 198
 199         stt_client_s* client = stt_client_get(*stt);
 200         if (NULL == client) {
 201                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to create client");
 202                 stt_client_destroy(*stt);
 203                 return STT_ERROR_OPERATION_FAILED;
 204         }
 205
 206         int ret = stt_config_mgr_initialize(client->uid);
 207         ret = __stt_convert_config_error_code(ret);
 208         if (0 != ret) {
 209                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to init config manager : %s", __stt_get_error_code(ret));
 210                 stt_client_destroy(*stt);
 211                 return ret;
 212         }
 213
 214         ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt);
 215         ret = __stt_convert_config_error_code(ret);
 216         if (0 != ret) {
 217                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret));
 218                 stt_client_destroy(*stt);
 219                 return ret;
 220         }
 221
 222         SLOG(LOG_DEBUG, TAG_STTC, "[Success] uid(%d)", (*stt)->handle);
 223
 224         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 225         SLOG(LOG_DEBUG, TAG_STTC, " ");
 226
 227         return STT_ERROR_NONE;
 228 }
 229
 230 int stt_destroy(stt_h stt)
 231 {
 232         if (0 != __stt_get_feature_enabled()) {
 233                 return STT_ERROR_NOT_SUPPORTED;
 234         }
 235
 236         SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT");
 237
 238         if (NULL == stt) {
 239                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
 240                 return STT_ERROR_INVALID_PARAMETER;
 241         }
 242
 243         stt_client_s* client = stt_client_get(stt);
 244
 245         /* check handle */
 246         if (NULL == client) {
 247                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 248                 return STT_ERROR_INVALID_PARAMETER;
 249         }
 250
 251         /* check used callback */
 252         if (0 != stt_client_get_use_callback(client)) {
 253                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function");
 254                 return STT_ERROR_OPERATION_FAILED;
 255         }
 256
 257         stt_config_mgr_finalize(client->uid);
 258
 259         int ret = -1;
 260
 261         /* check state */
 262         switch (client->current_state) {
 263         case STT_STATE_PROCESSING:
 264         case STT_STATE_RECORDING:
 265         case STT_STATE_READY:
 266                 ret = stt_dbus_request_finalize(client->uid);
 267                 if (0 != ret) {
 268                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
 269                 }
 270         case STT_STATE_CREATED:
 271                 if (NULL != g_connect_timer) {
 272                         SLOG(LOG_DEBUG, TAG_STTC, "Connect Timer is deleted");
 273                         ecore_timer_del(g_connect_timer);
 274                         g_connect_timer = NULL;
 275                 }
 276
 277                 /* Free resources */
 278                 stt_client_destroy(stt);
 279                 break;
 280         default:
 281                 break;
 282         }
 283
 284         if (0 == stt_client_get_size()) {
 285                 if (0 != stt_dbus_close_connection()) {
 286                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to close connection");
 287                 }
 288         }
 289
 290         stt = NULL;
 291
 292         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 293         SLOG(LOG_DEBUG, TAG_STTC, " ");
 294
 295         return STT_ERROR_NONE;
 296 }
 297
 298 bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_name,
 299                                       const char* setting, bool support_silence, void* user_data)
 300 {
 301         stt_h stt = (stt_h)user_data;
 302
 303         stt_client_s* client = stt_client_get(stt);
 304         if (NULL == client) {
 305                 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
 306                 return false;
 307         }
 308
 309         /* call callback function */
 310         if (NULL != client->supported_engine_cb) {
 311                 return client->supported_engine_cb(stt, engine_id, engine_name, client->supported_engine_user_data);
 312         } else {
 313                 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported engine");
 314         }
 315
 316         return false;
 317 }
 318
 319 int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data)
 320 {
 321         if (0 != __stt_get_feature_enabled()) {
 322                 return STT_ERROR_NOT_SUPPORTED;
 323         }
 324
 325         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine");
 326
 327         if (NULL == stt || NULL == callback) {
 328                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 329                 return STT_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         stt_client_s* client = stt_client_get(stt);
 333
 334         /* check handle */
 335         if (NULL == client) {
 336                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 337                 return STT_ERROR_INVALID_PARAMETER;
 338         }
 339
 340         if (client->current_state != STT_STATE_CREATED) {
 341                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
 342                 return STT_ERROR_INVALID_STATE;
 343         }
 344
 345         client->supported_engine_cb = callback;
 346         client->supported_engine_user_data = user_data;
 347
 348         int ret = 0;
 349         ret = stt_config_mgr_get_engine_list(__stt_config_supported_engine_cb, client->stt);
 350         ret = __stt_convert_config_error_code(ret);
 351         if (0 != ret) {
 352                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get engines : %s", __stt_get_error_code(ret));
 353         }
 354
 355         client->supported_engine_cb = NULL;
 356         client->supported_engine_user_data = NULL;
 357
 358         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 359         SLOG(LOG_DEBUG, TAG_STTC, " ");
 360
 361         return ret;
 362 }
 363
 364 int stt_get_engine(stt_h stt, char** engine_id)
 365 {
 366         if (0 != __stt_get_feature_enabled()) {
 367                 return STT_ERROR_NOT_SUPPORTED;
 368         }
 369
 370         SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine");
 371
 372         if (NULL == stt || NULL == engine_id) {
 373                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 374                 return STT_ERROR_INVALID_PARAMETER;
 375         }
 376
 377         stt_client_s* client = stt_client_get(stt);
 378
 379         /* check handle */
 380         if (NULL == client) {
 381                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 382                 return STT_ERROR_INVALID_PARAMETER;
 383         }
 384
 385         if (client->current_state != STT_STATE_CREATED) {
 386                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
 387                 return STT_ERROR_INVALID_STATE;
 388         }
 389
 390         int ret = 0;
 391
 392         if (NULL != client->current_engine_id) {
 393                 *engine_id = strdup(client->current_engine_id);
 394                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
 395         } else {
 396
 397                 ret = stt_config_mgr_get_engine(engine_id);
 398                 ret = __stt_convert_config_error_code(ret);
 399                 if (0 != ret) {
 400                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request get current engine : %s", __stt_get_error_code(ret));
 401                 } else {
 402                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", *engine_id);
 403                 }
 404         }
 405
 406         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 407         SLOG(LOG_DEBUG, TAG_STTC, " ");
 408
 409         return ret;
 410 }
 411
 412 int stt_set_engine(stt_h stt, const char* engine_id)
 413 {
 414         if (0 != __stt_get_feature_enabled()) {
 415                 return STT_ERROR_NOT_SUPPORTED;
 416         }
 417
 418         SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine");
 419
 420         if (NULL == stt || NULL == engine_id) {
 421                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 422                 return STT_ERROR_INVALID_PARAMETER;
 423         }
 424
 425         stt_client_s* client = stt_client_get(stt);
 426
 427         /* check handle */
 428         if (NULL == client) {
 429                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 430                 return STT_ERROR_INVALID_PARAMETER;
 431         }
 432
 433         /* check state */
 434         if (client->current_state != STT_STATE_CREATED) {
 435                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED", client->current_state);
 436                 return STT_ERROR_INVALID_STATE;
 437         }
 438
 439         if (NULL != client->current_engine_id) {
 440                 free(client->current_engine_id);
 441         }
 442
 443         client->current_engine_id = strdup(engine_id);
 444
 445         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 446         SLOG(LOG_DEBUG, TAG_STTC, " ");
 447
 448         return 0;
 449 }
 450
 451 int stt_set_credential(stt_h stt, const char* credential)
 452 {
 453         if (0 != __stt_get_feature_enabled()) {
 454                 return STT_ERROR_NOT_SUPPORTED;
 455         }
 456
 457         SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential");
 458
 459         if (NULL == stt || NULL == credential) {
 460                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL, stt(%s), credential(%a)", stt, credential);
 461                 return STT_ERROR_INVALID_PARAMETER;
 462         }
 463
 464         stt_client_s* client = stt_client_get(stt);
 465
 466         /* check handle */
 467         if (NULL == client) {
 468                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 469                 return STT_ERROR_INVALID_PARAMETER;
 470         }
 471
 472         /* check state */
 473         if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) {
 474                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state);
 475                 return STT_ERROR_INVALID_STATE;
 476         }
 477
 478         client->credential = strdup(credential);
 479
 480         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 481         SLOG(LOG_DEBUG, TAG_STTC, " ");
 482
 483         return STT_ERROR_NONE;
 484 }
 485
 486 static Eina_Bool __stt_connect_daemon(void *data)
 487 {
 488         stt_client_s* client = (stt_client_s*)data;
 489
 490         if (NULL == client) {
 491                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 492                 g_connect_timer = NULL;
 493                 return EINA_FALSE;
 494         }
 495
 496         /* Send hello */
 497         int ret = -1;
 498         ret = stt_dbus_request_hello();
 499
 500         if (0 != ret) {
 501                 if (STT_ERROR_INVALID_STATE == ret) {
 502                         g_connect_timer = NULL;
 503                         return EINA_FALSE;
 504                 }
 505                 return EINA_TRUE;
 506         }
 507
 508         g_connect_timer = NULL;
 509         SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon");
 510
 511         /* request initialization */
 512         bool silence_supported = false;
 513         bool credential_needed = false;
 514
 515         ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed);
 516
 517         if (STT_ERROR_ENGINE_NOT_FOUND == ret) {
 518                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
 519
 520                 client->reason = STT_ERROR_ENGINE_NOT_FOUND;
 521                 ecore_timer_add(0, __stt_notify_error, (void*)client);
 522
 523                 return EINA_FALSE;
 524
 525         } else if (STT_ERROR_NONE != ret) {
 526                 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect");
 527                 return EINA_TRUE;
 528         } else {
 529                 /* success to connect stt-daemon */
 530                 client->silence_supported = silence_supported;
 531                 client->credential_needed = credential_needed;
 532                 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
 533         }
 534
 535         if (NULL != client->current_engine_id) {
 536                 ret = -1;
 537                 int count = 0;
 538                 silence_supported = false;
 539                 credential_needed = false;
 540                 while (0 != ret) {
 541                         ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed);
 542                         if (0 != ret) {
 543                                 if (STT_ERROR_TIMED_OUT != ret) {
 544                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret));
 545                                         return ret;
 546                                 } else {
 547                                         SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
 548                                         usleep(10000);
 549                                         count++;
 550                                         if (STT_RETRY_COUNT == count) {
 551                                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
 552                                                 return ret;
 553                                         }
 554                                 }
 555                         } else {
 556                                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current engine uuid = %s", client->current_engine_id);
 557
 558                                 /* success to change engine */
 559                                 client->silence_supported = silence_supported;
 560                                 SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need");
 561                         }
 562                 }
 563         }
 564
 565         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid);
 566
 567         client->before_state = client->current_state;
 568         client->current_state = STT_STATE_READY;
 569
 570         if (NULL != client->state_changed_cb) {
 571                 stt_client_use_callback(client);
 572                 client->state_changed_cb(client->stt, client->before_state,
 573                         client->current_state, client->state_changed_user_data);
 574                 stt_client_not_use_callback(client);
 575                 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
 576         } else {
 577                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
 578         }
 579
 580         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 581         SLOG(LOG_DEBUG, TAG_STTC, "  ");
 582
 583         return EINA_FALSE;
 584 }
 585
 586 int stt_prepare(stt_h stt)
 587 {
 588         if (0 != __stt_get_feature_enabled()) {
 589                 return STT_ERROR_NOT_SUPPORTED;
 590         }
 591
 592         SLOG(LOG_DEBUG, TAG_STTC, "===== Prepare STT");
 593
 594         stt_client_s* client = stt_client_get(stt);
 595
 596         /* check handle */
 597         if (NULL == client) {
 598                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 599                 return STT_ERROR_INVALID_PARAMETER;
 600         }
 601
 602         /* check state */
 603         if (client->current_state != STT_STATE_CREATED) {
 604                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'CREATED'", client->current_state);
 605                 return STT_ERROR_INVALID_STATE;
 606         }
 607
 608         g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
 609
 610         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 611         SLOG(LOG_DEBUG, TAG_STTC, " ");
 612
 613         return STT_ERROR_NONE;
 614 }
 615
 616 int stt_unprepare(stt_h stt)
 617 {
 618         if (0 != __stt_get_feature_enabled()) {
 619                 return STT_ERROR_NOT_SUPPORTED;
 620         }
 621
 622         SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT");
 623
 624         stt_client_s* client = stt_client_get(stt);
 625
 626         /* check handle */
 627         if (NULL == client) {
 628                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 629                 return STT_ERROR_INVALID_PARAMETER;
 630         }
 631
 632         /* check state */
 633         if (client->current_state != STT_STATE_READY) {
 634                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state);
 635                 return STT_ERROR_INVALID_STATE;
 636         }
 637
 638         int ret = -1;
 639         int count = 0;
 640         while (0 != ret) {
 641                 ret = stt_dbus_request_finalize(client->uid);
 642                 if (0 != ret) {
 643                         if (STT_ERROR_TIMED_OUT != ret) {
 644                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request finalize : %s", __stt_get_error_code(ret));
 645                                 break;
 646                         } else {
 647                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
 648                                 usleep(10000);
 649                                 count++;
 650                                 if (STT_RETRY_COUNT == count) {
 651                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
 652                                         break;
 653                                 }
 654                         }
 655                 }
 656         }
 657
 658         client->internal_state = STT_INTERNAL_STATE_NONE;
 659
 660         client->before_state = client->current_state;
 661         client->current_state = STT_STATE_CREATED;
 662
 663         if (NULL != client->state_changed_cb) {
 664                 stt_client_use_callback(client);
 665                 client->state_changed_cb(client->stt, client->before_state,
 666                         client->current_state, client->state_changed_user_data);
 667                 stt_client_not_use_callback(client);
 668         } else {
 669                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
 670         }
 671
 672         if (g_connect_timer) {
 673                 ecore_timer_del(g_connect_timer);
 674                 g_connect_timer = NULL;
 675         }
 676
 677         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 678         SLOG(LOG_DEBUG, TAG_STTC, " ");
 679
 680         return STT_ERROR_NONE;
 681 }
 682
 683 bool __stt_config_supported_language_cb(const char* engine_id, const char* language, void* user_data)
 684 {
 685         stt_h stt = (stt_h)user_data;
 686
 687         stt_client_s* client = stt_client_get(stt);
 688         if (NULL == client) {
 689                 SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid");
 690                 return false;
 691         }
 692
 693         /* call callback function */
 694         if (NULL != client->supported_lang_cb) {
 695                 return client->supported_lang_cb(stt, language, client->supported_lang_user_data);
 696         } else {
 697                 SLOG(LOG_WARN, TAG_STTC, "No registered callback function of supported languages");
 698         }
 699
 700         return false;
 701 }
 702
 703 int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data)
 704 {
 705         if (0 != __stt_get_feature_enabled()) {
 706                 return STT_ERROR_NOT_SUPPORTED;
 707         }
 708
 709         SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language");
 710
 711         if (NULL == stt || NULL == callback) {
 712                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 713                 return STT_ERROR_INVALID_PARAMETER;
 714         }
 715
 716         stt_client_s* client = stt_client_get(stt);
 717
 718         /* check handle */
 719         if (NULL == client) {
 720                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 721                 return STT_ERROR_INVALID_PARAMETER;
 722         }
 723
 724         int ret;
 725         char* current_engine_id = NULL;
 726
 727         if (NULL == client->current_engine_id) {
 728                 ret = stt_config_mgr_get_engine(&current_engine_id);
 729                 ret = __stt_convert_config_error_code(ret);
 730                 if (0 != ret) {
 731                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default engine id : %s", __stt_get_error_code(ret));
 732                         return ret;
 733                 }
 734         } else {
 735                 current_engine_id = strdup(client->current_engine_id);
 736                 if (NULL == current_engine_id) {
 737                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 738                         return STT_ERROR_OUT_OF_MEMORY;
 739                 }
 740         }
 741
 742         client->supported_lang_cb = callback;
 743         client->supported_lang_user_data = user_data;
 744
 745         ret = stt_config_mgr_get_language_list(current_engine_id, __stt_config_supported_language_cb, client->stt);
 746         ret = __stt_convert_config_error_code(ret);
 747         if (0 != ret) {
 748                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get languages : %s", __stt_get_error_code(ret));
 749         }
 750
 751         if (NULL != current_engine_id) {
 752                 free(current_engine_id);
 753         }
 754
 755         client->supported_lang_cb = NULL;
 756         client->supported_lang_user_data = NULL;
 757
 758         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 759         SLOG(LOG_DEBUG, TAG_STTC, " ");
 760
 761         return ret;
 762 }
 763
 764 int stt_get_default_language(stt_h stt, char** language)
 765 {
 766         if (0 != __stt_get_feature_enabled()) {
 767                 return STT_ERROR_NOT_SUPPORTED;
 768         }
 769
 770         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language");
 771
 772         if (NULL == stt || NULL == language) {
 773                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 774                 return STT_ERROR_INVALID_PARAMETER;
 775         }
 776
 777         stt_client_s* client = stt_client_get(stt);
 778         if (NULL == client) {
 779                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
 780                 return STT_ERROR_INVALID_PARAMETER;
 781         }
 782
 783         int ret = 0;
 784         ret = stt_config_mgr_get_default_language(language);
 785         ret = __stt_convert_config_error_code(ret);
 786         if (0 != ret) {
 787                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get default language : %s", __stt_get_error_code(ret));
 788         } else {
 789                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Current language = %s", *language);
 790         }
 791
 792         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 793         SLOG(LOG_DEBUG, TAG_STTC, " ");
 794
 795         return ret;
 796 }
 797
 798 int stt_get_state(stt_h stt, stt_state_e* state)
 799 {
 800         if (0 != __stt_get_feature_enabled()) {
 801                 return STT_ERROR_NOT_SUPPORTED;
 802         }
 803
 804         if (NULL == stt || NULL == state) {
 805                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 806                 return STT_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         stt_client_s* client = stt_client_get(stt);
 810         if (NULL == client) {
 811                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
 812                 return STT_ERROR_INVALID_PARAMETER;
 813         }
 814
 815         *state = client->current_state;
 816
 817         switch (*state) {
 818         case STT_STATE_CREATED:         SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'");        break;
 819         case STT_STATE_READY:           SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'");          break;
 820         case STT_STATE_RECORDING:       SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'");      break;
 821         case STT_STATE_PROCESSING:      SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'");     break;
 822         default:                        SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value");             break;
 823         }
 824
 825         return STT_ERROR_NONE;
 826 }
 827
 828 int stt_get_error_message(stt_h stt, char** err_msg)
 829 {
 830         if (0 != __stt_get_feature_enabled()) {
 831                 return STT_ERROR_NOT_SUPPORTED;
 832         }
 833
 834         if (NULL == stt || NULL == err_msg) {
 835                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 836                 return STT_ERROR_INVALID_PARAMETER;
 837         }
 838
 839         if (false == g_err_callback_status) {
 840                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback");
 841                 return STT_ERROR_OPERATION_FAILED;
 842         }
 843
 844         stt_client_s* client = stt_client_get(stt);
 845         if (NULL == client) {
 846                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get error msg : A handle is not valid");
 847                 return STT_ERROR_INVALID_PARAMETER;
 848         }
 849
 850         if (NULL != client->err_msg) {
 851                 *err_msg = strdup(client->err_msg);
 852                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg);
 853         } else {
 854                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)");
 855         }
 856
 857         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 858         SLOG(LOG_DEBUG, TAG_STTC, " ");
 859
 860         return STT_ERROR_NONE;
 861 }
 862
 863 int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support)
 864 {
 865         if (0 != __stt_get_feature_enabled()) {
 866                 return STT_ERROR_NOT_SUPPORTED;
 867         }
 868
 869         if (NULL == stt || NULL == type || NULL == support) {
 870                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 871                 return STT_ERROR_INVALID_PARAMETER;
 872         }
 873
 874         stt_client_s* client = stt_client_get(stt);
 875         if (NULL == client) {
 876                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not valid");
 877                 return STT_ERROR_INVALID_PARAMETER;
 878         }
 879
 880         /* check state */
 881         if (client->current_state != STT_STATE_READY) {
 882                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
 883                 return STT_ERROR_INVALID_STATE;
 884         }
 885
 886         int ret = -1;
 887         int count = 0;
 888         while (0 != ret) {
 889                 ret = stt_dbus_request_is_recognition_type_supported(client->uid, type, support);
 890                 if (0 != ret) {
 891                         if (STT_ERROR_TIMED_OUT != ret) {
 892                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get recognition type supported : %s", __stt_get_error_code(ret));
 893                                 return ret;
 894                         } else {
 895                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
 896                                 usleep(10000);
 897                                 count++;
 898                                 if (STT_RETRY_COUNT == count) {
 899                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
 900                                         return ret;
 901                                 }
 902                         }
 903                 } else {
 904                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] recognition type is %s", *support ? "true " : "false");
 905                         break;
 906                 }
 907         }
 908
 909         return STT_ERROR_NONE;
 910 }
 911
 912 int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type)
 913 {
 914         if (0 != __stt_get_feature_enabled()) {
 915                 return STT_ERROR_NOT_SUPPORTED;
 916         }
 917
 918         if (NULL == stt) {
 919                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 920                 return STT_ERROR_INVALID_PARAMETER;
 921         }
 922
 923         stt_client_s* client = stt_client_get(stt);
 924         if (NULL == client) {
 925                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
 926                 return STT_ERROR_INVALID_PARAMETER;
 927         }
 928
 929         /* check state */
 930         if (client->current_state != STT_STATE_READY) {
 931                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
 932                 return STT_ERROR_INVALID_STATE;
 933         }
 934
 935         if (true == client->silence_supported) {
 936                 if (type >= STT_OPTION_SILENCE_DETECTION_FALSE && type <= STT_OPTION_SILENCE_DETECTION_AUTO) {
 937                         client->silence = type;
 938                 } else {
 939                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Type is invalid");
 940                         return STT_ERROR_INVALID_PARAMETER;
 941                 }
 942         } else {
 943                 return STT_ERROR_NOT_SUPPORTED_FEATURE;
 944         }
 945
 946         return STT_ERROR_NONE;
 947 }
 948
 949 int stt_set_start_sound(stt_h stt, const char* filename)
 950 {
 951         if (0 != __stt_get_feature_enabled()) {
 952                 return STT_ERROR_NOT_SUPPORTED;
 953         }
 954
 955         SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND");
 956
 957         if (NULL == stt || NULL == filename) {
 958                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
 959                 return STT_ERROR_INVALID_PARAMETER;
 960         }
 961
 962         if (0 != access(filename, F_OK)) {
 963                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
 964                 return STT_ERROR_INVALID_PARAMETER;
 965         }
 966
 967         stt_client_s* client = stt_client_get(stt);
 968         if (NULL == client) {
 969                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
 970                 return STT_ERROR_INVALID_PARAMETER;
 971         }
 972
 973         /* check state */
 974         if (client->current_state != STT_STATE_READY) {
 975                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
 976                 return STT_ERROR_INVALID_STATE;
 977         }
 978
 979         int ret = -1;
 980         int count = 0;
 981         while (0 != ret) {
 982                 ret = stt_dbus_request_set_start_sound(client->uid, filename);
 983                 if (0 != ret) {
 984                         if (STT_ERROR_TIMED_OUT != ret) {
 985                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set start sound : %s", __stt_get_error_code(ret));
 986                                 return ret;
 987                         } else {
 988                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
 989                                 usleep(10000);
 990                                 count++;
 991                                 if (STT_RETRY_COUNT == count) {
 992                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
 993                                         return ret;
 994                                 }
 995                         }
 996                 } else {
 997                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set start sound : %s", filename);
 998                         break;
 999                 }
1000         }
1001
1002         return STT_ERROR_NONE;
1003 }
1004
1005 int stt_unset_start_sound(stt_h stt)
1006 {
1007         if (0 != __stt_get_feature_enabled()) {
1008                 return STT_ERROR_NOT_SUPPORTED;
1009         }
1010
1011         SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND");
1012
1013         if (NULL == stt) {
1014                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1015                 return STT_ERROR_INVALID_PARAMETER;
1016         }
1017
1018         stt_client_s* client = stt_client_get(stt);
1019
1020         if (NULL == client) {
1021                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1022                 return STT_ERROR_INVALID_PARAMETER;
1023         }
1024
1025         /* check state */
1026         if (client->current_state != STT_STATE_READY) {
1027                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1028                 return STT_ERROR_INVALID_STATE;
1029         }
1030
1031         int ret = -1;
1032         int count = 0;
1033         while (0 != ret) {
1034                 ret = stt_dbus_request_unset_start_sound(client->uid);
1035                 if (0 != ret) {
1036                         if (STT_ERROR_TIMED_OUT != ret) {
1037                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset start sound : %s", __stt_get_error_code(ret));
1038                                 return ret;
1039                         } else {
1040                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1041                                 usleep(10000);
1042                                 count++;
1043                                 if (STT_RETRY_COUNT == count) {
1044                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1045                                         return ret;
1046                                 }
1047                         }
1048                 } else {
1049                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset start sound");
1050                         break;
1051                 }
1052         }
1053
1054         return STT_ERROR_NONE;
1055 }
1056
1057 int stt_set_stop_sound(stt_h stt, const char* filename)
1058 {
1059         if (0 != __stt_get_feature_enabled()) {
1060                 return STT_ERROR_NOT_SUPPORTED;
1061         }
1062
1063         SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND");
1064
1065         if (NULL == stt || NULL == filename) {
1066                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1067                 return STT_ERROR_INVALID_PARAMETER;
1068         }
1069
1070         if (0 != access(filename, F_OK)) {
1071                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] File does not exist");
1072                 return STT_ERROR_INVALID_PARAMETER;
1073         }
1074
1075         stt_client_s* client = stt_client_get(stt);
1076
1077         if (NULL == client) {
1078                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1079                 return STT_ERROR_INVALID_PARAMETER;
1080         }
1081
1082         /* check state */
1083         if (client->current_state != STT_STATE_READY) {
1084                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1085                 return STT_ERROR_INVALID_STATE;
1086         }
1087
1088         int ret = -1;
1089         int count = 0;
1090         while (0 != ret) {
1091                 ret = stt_dbus_request_set_stop_sound(client->uid, filename);
1092                 if (0 != ret) {
1093                         if (STT_ERROR_TIMED_OUT != ret) {
1094                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set stop sound : %s", __stt_get_error_code(ret));
1095                                 return ret;
1096                         } else {
1097                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1098                                 usleep(10000);
1099                                 count++;
1100                                 if (STT_RETRY_COUNT == count) {
1101                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1102                                         return ret;
1103                                 }
1104                         }
1105                 } else {
1106                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Set stop sound : %s", filename);
1107                         break;
1108                 }
1109         }
1110
1111         return STT_ERROR_NONE;
1112 }
1113
1114 int stt_unset_stop_sound(stt_h stt)
1115 {
1116         if (0 != __stt_get_feature_enabled()) {
1117                 return STT_ERROR_NOT_SUPPORTED;
1118         }
1119
1120         SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND");
1121
1122         if (NULL == stt) {
1123                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1124                 return STT_ERROR_INVALID_PARAMETER;
1125         }
1126
1127         stt_client_s* client = stt_client_get(stt);
1128
1129         if (NULL == client) {
1130                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid");
1131                 return STT_ERROR_INVALID_PARAMETER;
1132         }
1133
1134         /* check state */
1135         if (client->current_state != STT_STATE_READY) {
1136                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1137                 return STT_ERROR_INVALID_STATE;
1138         }
1139
1140         int ret = -1;
1141         int count = 0;
1142         while (0 != ret) {
1143                 ret = stt_dbus_request_unset_stop_sound(client->uid);
1144                 if (0 != ret) {
1145                         if (STT_ERROR_TIMED_OUT != ret) {
1146                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to unset stop sound : %s", __stt_get_error_code(ret));
1147                                 return ret;
1148                         } else {
1149                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1150                                 usleep(10000);
1151                                 count++;
1152                                 if (STT_RETRY_COUNT == count) {
1153                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1154                                         return ret;
1155                                 }
1156                         }
1157                 } else {
1158                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Unset stop sound");
1159                         break;
1160                 }
1161         }
1162
1163         return STT_ERROR_NONE;
1164 }
1165
1166 int stt_start(stt_h stt, const char* language, const char* type)
1167 {
1168         if (0 != __stt_get_feature_enabled()) {
1169                 return STT_ERROR_NOT_SUPPORTED;
1170         }
1171
1172         SLOG(LOG_DEBUG, TAG_STTC, "===== STT START");
1173
1174         if (NULL == stt) {
1175                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1176                 return STT_ERROR_INVALID_PARAMETER;
1177         }
1178
1179         stt_client_s* client = stt_client_get(stt);
1180         if (NULL == client) {
1181                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1182                 return STT_ERROR_INVALID_PARAMETER;
1183         }
1184
1185         /* check state */
1186         if (client->current_state != STT_STATE_READY) {
1187                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state);
1188                 return STT_ERROR_INVALID_STATE;
1189         }
1190
1191         if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1192                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1193                 return STT_ERROR_INVALID_STATE;
1194         }
1195
1196         int ret = -1;
1197         char appid[128] = {0, };
1198         ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1199
1200         if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
1201                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
1202         } else {
1203                 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
1204         }
1205
1206         char* temp = NULL;
1207         if (NULL == language) {
1208                 temp = strdup("default");
1209         } else {
1210                 temp = strdup(language);
1211         }
1212
1213 #if 0
1214         ret = -1;
1215         /* do request */
1216         int count = 0;
1217         while (0 != ret) {
1218                 ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid);
1219                 if (0 > ret) {
1220                         /* Failure */
1221                         if (STT_ERROR_TIMED_OUT != ret) {
1222                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1223                                 if (NULL != temp)       free(temp);
1224                                 return ret;
1225                         } else {
1226                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry to start");
1227                                 usleep(10000);
1228                                 count++;
1229                                 if (STT_RETRY_COUNT == count) {
1230                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1231                                         if (NULL != temp)       free(temp);
1232                                         return ret;
1233                                 }
1234                         }
1235                 } else {
1236                         /* Success */
1237                         if (NULL != temp)       free(temp);
1238
1239                         if (STT_RESULT_STATE_DONE == ret) {
1240                                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is done : %d", ret);
1241                                 client->before_state = client->current_state;
1242                                 client->current_state = STT_STATE_RECORDING;
1243
1244                                 if (NULL != client->state_changed_cb) {
1245                                         ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1246                                 } else {
1247                                         SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1248                                 }
1249                         } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1250                                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is not done : %d", ret);
1251                                 client->internal_state = STT_INTERNAL_STATE_STARTING;
1252                         } else {
1253                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1254                         }
1255
1256                         ret = STT_ERROR_NONE;
1257                         break;
1258                 }
1259         }
1260 #else
1261         if (true == client->credential_needed && NULL == client->credential) {
1262                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id);
1263                 return STT_ERROR_PERMISSION_DENIED;
1264         }
1265
1266         ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential);
1267         if (0 != ret) {
1268                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret));
1269         } else {
1270                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
1271                 client->internal_state = STT_INTERNAL_STATE_STARTING;
1272         }
1273
1274         if (NULL != temp)       free(temp);
1275 #endif
1276         SLOG(LOG_DEBUG, TAG_STTC, "=====");
1277         SLOG(LOG_DEBUG, TAG_STTC, " ");
1278
1279         return ret;
1280 }
1281
1282 int stt_stop(stt_h stt)
1283 {
1284         if (0 != __stt_get_feature_enabled()) {
1285                 return STT_ERROR_NOT_SUPPORTED;
1286         }
1287
1288         SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP");
1289
1290         if (NULL == stt) {
1291                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1292                 return STT_ERROR_INVALID_PARAMETER;
1293         }
1294
1295         stt_client_s* client = stt_client_get(stt);
1296         if (NULL == client) {
1297                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1298                 return STT_ERROR_INVALID_PARAMETER;
1299         }
1300
1301         /* check state */
1302         if (client->current_state != STT_STATE_RECORDING) {
1303                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state);
1304                 return STT_ERROR_INVALID_STATE;
1305         }
1306
1307         if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1308                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1309                 return STT_ERROR_INVALID_STATE;
1310         }
1311 #if 0
1312         int ret = -1;
1313         /* do request */
1314         int count = 0;
1315         while (0 != ret) {
1316                 ret = stt_dbus_request_stop(client->uid);
1317                 if (0 > ret) {
1318                         /* Failure */
1319                         if (STT_ERROR_TIMED_OUT != ret) {
1320                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1321                                 return ret;
1322                         } else {
1323                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry stop");
1324                                 usleep(10000);
1325                                 count++;
1326                                 if (STT_RETRY_COUNT == count) {
1327                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1328                                         return ret;
1329                                 }
1330                         }
1331                 } else {
1332                         if (STT_RESULT_STATE_DONE == ret) {
1333                                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is done : %d", ret);
1334                                 client->before_state = client->current_state;
1335                                 client->current_state = STT_STATE_PROCESSING;
1336
1337                                 if (NULL != client->state_changed_cb) {
1338                                         ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1339                                         SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1340                                 } else {
1341                                         SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1342                                 }
1343                         } else if (STT_RESULT_STATE_NOT_DONE == ret) {
1344                                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is not done : %d", ret);
1345                                 client->internal_state = STT_INTERNAL_STATE_STOPING;
1346                         } else {
1347                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret);
1348                         }
1349                         ret = STT_ERROR_NONE;
1350                         break;
1351                 }
1352         }
1353 #else
1354         int ret = stt_dbus_request_stop(client->uid);
1355
1356         if (0 != ret) {
1357                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret));
1358         } else {
1359                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
1360                 client->internal_state = STT_INTERNAL_STATE_STOPING;
1361         }
1362 #endif
1363         SLOG(LOG_DEBUG, TAG_STTC, "=====");
1364         SLOG(LOG_DEBUG, TAG_STTC, " ");
1365
1366         return ret;
1367 }
1368
1369
1370 int stt_cancel(stt_h stt)
1371 {
1372         if (0 != __stt_get_feature_enabled()) {
1373                 return STT_ERROR_NOT_SUPPORTED;
1374         }
1375
1376         SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL");
1377
1378         if (NULL == stt) {
1379                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null");
1380                 return STT_ERROR_INVALID_PARAMETER;
1381         }
1382
1383         stt_client_s* client = stt_client_get(stt);
1384
1385         /* check handle */
1386         if (NULL == client) {
1387                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1388                 return STT_ERROR_INVALID_PARAMETER;
1389         }
1390
1391         /* check state */
1392         if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) {
1393                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state);
1394                 return STT_ERROR_INVALID_STATE;
1395         }
1396
1397         if (STT_INTERNAL_STATE_NONE != client->internal_state) {
1398                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state);
1399                 return STT_ERROR_INVALID_STATE;
1400         }
1401 #if 0
1402         int ret = -1;
1403         /* do request */
1404         int count = 0;
1405         while (0 != ret) {
1406                 ret = stt_dbus_request_cancel(client->uid);
1407                 if (0 != ret) {
1408                         /* Failure */
1409                         if (STT_ERROR_TIMED_OUT != ret) {
1410                                 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1411                                 return ret;
1412                         } else {
1413                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry");
1414                                 usleep(10000);
1415                                 count++;
1416                                 if (STT_RETRY_COUNT == count) {
1417                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request");
1418                                         return ret;
1419                                 }
1420                         }
1421                 } else {
1422                         SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]");
1423
1424                         client->before_state = client->current_state;
1425                         client->current_state = STT_STATE_READY;
1426
1427                         if (NULL != client->state_changed_cb) {
1428                                 ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1429                                 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1430                         } else {
1431                                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1432                         }
1433                         ret = STT_ERROR_NONE;
1434                         break;
1435                 }
1436         }
1437 #else
1438         int ret = stt_dbus_request_cancel(client->uid);
1439         if (0 != ret) {
1440                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret));
1441         } else {
1442                 SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
1443                 client->internal_state = STT_INTERNAL_STATE_CANCELING;
1444         }
1445 #endif
1446         SLOG(LOG_DEBUG, TAG_STTC, "=====");
1447         SLOG(LOG_DEBUG, TAG_STTC, " ");
1448
1449         return ret;
1450 }
1451
1452 int __stt_cb_set_volume(int uid, float volume)
1453 {
1454         stt_client_s* client = NULL;
1455
1456         client = stt_client_get_by_uid(uid);
1457         if (NULL == client) {
1458                 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1459                 return STT_ERROR_INVALID_PARAMETER;
1460         }
1461
1462         if (STT_STATE_RECORDING != client->current_state) {
1463                 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1464                 return STT_ERROR_INVALID_STATE;
1465         }
1466
1467         g_volume_db = volume;
1468         SLOG(LOG_DEBUG, TAG_STTC, "Set volume (%f)", g_volume_db);
1469
1470         return 0;
1471 }
1472
1473 int stt_get_recording_volume(stt_h stt, float* volume)
1474 {
1475         if (0 != __stt_get_feature_enabled()) {
1476                 return STT_ERROR_NOT_SUPPORTED;
1477         }
1478
1479         if (NULL == stt || NULL == volume) {
1480                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1481                 return STT_ERROR_INVALID_PARAMETER;
1482         }
1483
1484         stt_client_s* client = stt_client_get(stt);
1485
1486         /* check handle */
1487         if (NULL == client) {
1488                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1489                 return STT_ERROR_INVALID_PARAMETER;
1490         }
1491
1492         if (STT_STATE_RECORDING != client->current_state) {
1493                 SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Invalid state : NO 'Recording' state, cur(%d)", client->current_state);
1494                 return STT_ERROR_INVALID_STATE;
1495         }
1496
1497         *volume = g_volume_db;
1498
1499         return STT_ERROR_NONE;
1500 }
1501
1502 bool __stt_result_time_cb(int index, int event, const char* text, long start_time, long end_time, void* user_data)
1503 {
1504         stt_client_s* client = (stt_client_s*)user_data;
1505
1506         /* check handle */
1507         if (NULL == client) {
1508                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1509                 return EINA_FALSE;
1510         }
1511
1512         if (NULL != client->result_time_cb) {
1513                 SLOG(LOG_DEBUG, TAG_STTC, "(%d) event(%d) text(%s) start(%ld) end(%ld)",
1514                         index, event, text, start_time, end_time);
1515                 client->result_time_cb(client->stt, index, (stt_result_time_event_e)event,
1516                         text, start_time, end_time, client->result_time_user_data);
1517         } else {
1518                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Callback is NULL");
1519                 return false;
1520         }
1521
1522         return true;
1523 }
1524
1525 int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data)
1526 {
1527         if (0 != __stt_get_feature_enabled()) {
1528                 return STT_ERROR_NOT_SUPPORTED;
1529         }
1530
1531         SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT");
1532
1533         if (NULL == callback) {
1534                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
1535                 return STT_ERROR_INVALID_PARAMETER;
1536         }
1537
1538         stt_client_s* client = stt_client_get(stt);
1539
1540         /* check handle */
1541         if (NULL == client) {
1542                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail : A handle is not valid");
1543                 return STT_ERROR_INVALID_PARAMETER;
1544         }
1545
1546         client->result_time_cb = callback;
1547         client->result_time_user_data = user_data;
1548
1549         int ret = -1;
1550         ret = stt_config_mgr_foreach_time_info(__stt_result_time_cb, client);
1551         ret = __stt_convert_config_error_code(ret);
1552         if (0 != ret) {
1553                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to foreach time info : %s", __stt_get_error_code(ret));
1554         }
1555
1556         client->result_time_cb = NULL;
1557         client->result_time_user_data = NULL;
1558
1559         SLOG(LOG_DEBUG, TAG_STTC, "=====");
1560         SLOG(LOG_DEBUG, TAG_STTC, " ");
1561
1562         return ret;
1563 }
1564
1565 static Eina_Bool __stt_notify_error(void *data)
1566 {
1567         stt_client_s* client = (stt_client_s*)data;
1568
1569         SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error from sttd");
1570
1571         /* check handle */
1572         if (NULL == client) {
1573                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1574                 return EINA_FALSE;
1575         }
1576
1577         if (NULL == stt_client_get_by_uid(client->uid))
1578                 return EINA_FALSE;
1579
1580         if (NULL != client->error_cb) {
1581                 stt_client_use_callback(client);
1582                 g_err_callback_status = true;
1583                 client->error_cb(client->stt, client->reason, client->error_user_data);
1584                 g_err_callback_status = false;
1585                 stt_client_not_use_callback(client);
1586                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason);
1587         } else {
1588                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1589         }
1590
1591         return EINA_FALSE;
1592 }
1593
1594 int __stt_cb_error(int uid, int reason, char* err_msg)
1595 {
1596         stt_client_s* client = stt_client_get_by_uid(uid);
1597         if (NULL == client) {
1598                 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1599                 return -1;
1600         }
1601
1602         client->reason = reason;
1603         client->internal_state = STT_INTERNAL_STATE_NONE;
1604         if (NULL != client->err_msg) {
1605                 free(client->err_msg);
1606                 client->err_msg = NULL;
1607         }
1608         client->err_msg = strdup(err_msg);
1609
1610         SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
1611
1612         if (NULL != client->error_cb) {
1613                 ecore_timer_add(0, __stt_notify_error, client);
1614         } else {
1615                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
1616         }
1617
1618         return 0;
1619 }
1620
1621 static void __stt_notify_state_changed(void *data)
1622 {
1623         stt_client_s* client = (stt_client_s*)data;
1624
1625         /* check handle */
1626         if (NULL == client) {
1627                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1628                 return;
1629         }
1630
1631         if (NULL == stt_client_get_by_uid(client->uid)) {
1632                 return;
1633         }
1634
1635         if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) {
1636                 client->internal_state = STT_INTERNAL_STATE_NONE;
1637                 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1638         } else if (STT_INTERNAL_STATE_STOPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) {
1639                 client->internal_state = STT_INTERNAL_STATE_NONE;
1640                 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1641         } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) {
1642                 client->internal_state = STT_INTERNAL_STATE_NONE;
1643                 SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE");
1644         }
1645
1646         if (NULL != client->state_changed_cb) {
1647                 stt_client_use_callback(client);
1648                 client->state_changed_cb(client->stt, client->before_state,
1649                         client->current_state, client->state_changed_user_data);
1650                 stt_client_not_use_callback(client);
1651                 SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
1652         } else {
1653                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1654         }
1655
1656         return;
1657 }
1658
1659 static Eina_Bool __stt_notify_result(void *data)
1660 {
1661         stt_client_s* client = (stt_client_s*)data;
1662
1663         /* check handle */
1664         if (NULL == client) {
1665                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
1666                 return EINA_FALSE;
1667         }
1668
1669         if (NULL == stt_client_get_by_uid(client->uid)) {
1670                 return EINA_FALSE;
1671         }
1672
1673         if (NULL != client->recognition_result_cb) {
1674                 stt_client_use_callback(client);
1675                 client->recognition_result_cb(client->stt, client->event, (const char**)client->data_list, client->data_count,
1676                         client->msg, client->recognition_result_user_data);
1677                 stt_client_not_use_callback(client);
1678                 SLOG(LOG_DEBUG, TAG_STTC, "client recognition result callback called");
1679         } else {
1680                 SLOG(LOG_WARN, TAG_STTC, "[WARNING] User recognition result callback is NULL");
1681         }
1682
1683         if (NULL != client->msg) {
1684                 free(client->msg);
1685                 client->msg = NULL;
1686         }
1687
1688         if (NULL != client->data_list) {
1689                 char **temp = NULL;
1690                 temp = client->data_list;
1691
1692                 int i = 0;
1693                 for (i = 0; i < client->data_count; i++) {
1694                         if (NULL != temp[i]) {
1695                                 free(temp[i]);
1696                                 temp[i] = NULL;
1697                         } else {
1698                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1699                         }
1700                 }
1701                 free(client->data_list);
1702                 client->data_list = NULL;
1703         }
1704
1705         client->data_count = 0;
1706
1707         stt_config_mgr_remove_time_info_file();
1708
1709         if (STT_RESULT_EVENT_FINAL_RESULT == client->event || STT_RESULT_EVENT_ERROR == client->event) {
1710                 client->before_state = client->current_state;
1711                 client->current_state = STT_STATE_READY;
1712
1713                 if (NULL != client->state_changed_cb) {
1714                         ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1715                 } else {
1716                         SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
1717                 }
1718         }
1719
1720         return EINA_FALSE;
1721 }
1722
1723 int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg)
1724 {
1725         stt_client_s* client = NULL;
1726
1727         client = stt_client_get_by_uid(uid);
1728         if (NULL == client) {
1729                 SLOG(LOG_ERROR, TAG_STTC, "Handle is NOT valid");
1730                 return STT_ERROR_INVALID_PARAMETER;
1731         }
1732
1733         if (NULL != msg)
1734                 SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
1735
1736         int i = 0;
1737         for (i = 0; i < data_count; i++) {
1738                 if (NULL != data[i])
1739                         SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
1740         }
1741
1742         if (NULL != client->recognition_result_cb) {
1743                 client->event = event;
1744                 if (NULL != msg) {
1745                         client->msg = strdup(msg);
1746                 }
1747
1748                 client->data_count = data_count;
1749
1750                 if (data_count > 0) {
1751                         char **temp = NULL;
1752                         temp = (char**)calloc(data_count, sizeof(char*));
1753                         if (NULL == temp) {
1754                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
1755                                 return STT_ERROR_OUT_OF_MEMORY;
1756                         }
1757
1758                         for (i = 0; i < data_count; i++) {
1759                                 if (NULL != data[i])
1760                                         temp[i] = strdup(data[i]);
1761                                 else
1762                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Result data is error");
1763                         }
1764
1765                         client->data_list = temp;
1766                 }
1767         } else {
1768                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
1769         }
1770
1771         ecore_timer_add(0, __stt_notify_result, client);
1772
1773         return STT_ERROR_NONE;
1774 }
1775
1776 int __stt_cb_set_state(int uid, int state)
1777 {
1778         stt_client_s* client = stt_client_get_by_uid(uid);
1779         if (NULL == client) {
1780                 SLOG(LOG_ERROR, TAG_STTC, "Handle not found");
1781                 return -1;
1782         }
1783
1784         stt_state_e state_from_daemon = (stt_state_e)state;
1785
1786         if (client->current_state == state_from_daemon) {
1787                 SLOG(LOG_DEBUG, TAG_STTC, "Current state has already been %d", client->current_state);
1788                 return 0;
1789         }
1790
1791         client->before_state = client->current_state;
1792         client->current_state = state_from_daemon;
1793
1794         ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client);
1795         return 0;
1796 }
1797
1798 int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data)
1799 {
1800         if (0 != __stt_get_feature_enabled()) {
1801                 return STT_ERROR_NOT_SUPPORTED;
1802         }
1803
1804         if (stt == NULL || callback == NULL)
1805                 return STT_ERROR_INVALID_PARAMETER;
1806
1807         stt_client_s* client = stt_client_get(stt);
1808
1809         /* check handle */
1810         if (NULL == client) {
1811                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1812                 return STT_ERROR_INVALID_PARAMETER;
1813         }
1814
1815         if (STT_STATE_CREATED != client->current_state) {
1816                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1817                 return STT_ERROR_INVALID_STATE;
1818         }
1819
1820         client->recognition_result_cb = callback;
1821         client->recognition_result_user_data = user_data;
1822
1823         return 0;
1824 }
1825
1826 int stt_unset_recognition_result_cb(stt_h stt)
1827 {
1828         if (0 != __stt_get_feature_enabled()) {
1829                 return STT_ERROR_NOT_SUPPORTED;
1830         }
1831
1832         if (NULL == stt)
1833                 return STT_ERROR_INVALID_PARAMETER;
1834
1835         stt_client_s* client = stt_client_get(stt);
1836
1837         /* check handle */
1838         if (NULL == client) {
1839                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1840                 return STT_ERROR_INVALID_PARAMETER;
1841         }
1842
1843         if (STT_STATE_CREATED != client->current_state) {
1844                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1845                 return STT_ERROR_INVALID_STATE;
1846         }
1847
1848         client->recognition_result_cb = NULL;
1849         client->recognition_result_user_data = NULL;
1850
1851         return 0;
1852 }
1853
1854 int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data)
1855 {
1856         if (0 != __stt_get_feature_enabled()) {
1857                 return STT_ERROR_NOT_SUPPORTED;
1858         }
1859
1860         if (NULL == stt || NULL == callback)
1861                 return STT_ERROR_INVALID_PARAMETER;
1862
1863         stt_client_s* client = stt_client_get(stt);
1864
1865         /* check handle */
1866         if (NULL == client) {
1867                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1868                 return STT_ERROR_INVALID_PARAMETER;
1869         }
1870
1871         if (STT_STATE_CREATED != client->current_state) {
1872                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1873                 return STT_ERROR_INVALID_STATE;
1874         }
1875
1876         client->state_changed_cb = callback;
1877         client->state_changed_user_data = user_data;
1878
1879         return 0;
1880 }
1881
1882 int stt_unset_state_changed_cb(stt_h stt)
1883 {
1884         if (0 != __stt_get_feature_enabled()) {
1885                 return STT_ERROR_NOT_SUPPORTED;
1886         }
1887
1888         if (NULL == stt)
1889                 return STT_ERROR_INVALID_PARAMETER;
1890
1891         stt_client_s* client = stt_client_get(stt);
1892
1893         /* check handle */
1894         if (NULL == client) {
1895                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1896                 return STT_ERROR_INVALID_PARAMETER;
1897         }
1898
1899         if (STT_STATE_CREATED != client->current_state) {
1900                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1901                 return STT_ERROR_INVALID_STATE;
1902         }
1903
1904         client->state_changed_cb = NULL;
1905         client->state_changed_user_data = NULL;
1906
1907         return 0;
1908 }
1909
1910 int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data)
1911 {
1912         if (0 != __stt_get_feature_enabled()) {
1913                 return STT_ERROR_NOT_SUPPORTED;
1914         }
1915
1916         if (NULL == stt || NULL == callback)
1917                 return STT_ERROR_INVALID_PARAMETER;
1918
1919         stt_client_s* client = stt_client_get(stt);
1920
1921         /* check handle */
1922         if (NULL == client) {
1923                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1924                 return STT_ERROR_INVALID_PARAMETER;
1925         }
1926
1927         if (STT_STATE_CREATED != client->current_state) {
1928                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1929                 return STT_ERROR_INVALID_STATE;
1930         }
1931
1932         client->error_cb = callback;
1933         client->error_user_data = user_data;
1934
1935         return 0;
1936 }
1937
1938 int stt_unset_error_cb(stt_h stt)
1939 {
1940         if (0 != __stt_get_feature_enabled()) {
1941                 return STT_ERROR_NOT_SUPPORTED;
1942         }
1943
1944         if (NULL == stt)
1945                 return STT_ERROR_INVALID_PARAMETER;
1946
1947         stt_client_s* client = stt_client_get(stt);
1948
1949         /* check handle */
1950         if (NULL == client) {
1951                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1952                 return STT_ERROR_INVALID_PARAMETER;
1953         }
1954
1955         if (STT_STATE_CREATED != client->current_state) {
1956                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1957                 return STT_ERROR_INVALID_STATE;
1958         }
1959
1960         client->error_cb = NULL;
1961         client->error_user_data = NULL;
1962
1963         return 0;
1964 }
1965
1966 int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data)
1967 {
1968         if (0 != __stt_get_feature_enabled()) {
1969                 return STT_ERROR_NOT_SUPPORTED;
1970         }
1971
1972         if (NULL == stt || NULL == callback)
1973                 return STT_ERROR_INVALID_PARAMETER;
1974
1975         stt_client_s* client = stt_client_get(stt);
1976
1977         /* check handle */
1978         if (NULL == client) {
1979                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
1980                 return STT_ERROR_INVALID_PARAMETER;
1981         }
1982
1983         if (STT_STATE_CREATED != client->current_state) {
1984                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
1985                 return STT_ERROR_INVALID_STATE;
1986         }
1987
1988         client->default_lang_changed_cb = callback;
1989         client->default_lang_changed_user_data = user_data;
1990
1991         return 0;
1992 }
1993
1994 int stt_unset_default_language_changed_cb(stt_h stt)
1995 {
1996         if (0 != __stt_get_feature_enabled()) {
1997                 return STT_ERROR_NOT_SUPPORTED;
1998         }
1999
2000         if (NULL == stt)
2001                 return STT_ERROR_INVALID_PARAMETER;
2002
2003         stt_client_s* client = stt_client_get(stt);
2004
2005         /* check handle */
2006         if (NULL == client) {
2007                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2008                 return STT_ERROR_INVALID_PARAMETER;
2009         }
2010
2011         if (STT_STATE_CREATED != client->current_state) {
2012                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2013                 return STT_ERROR_INVALID_STATE;
2014         }
2015
2016         client->default_lang_changed_cb = NULL;
2017         client->default_lang_changed_user_data = NULL;
2018
2019         return 0;
2020 }
2021
2022 int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data)
2023 {
2024         if (0 != __stt_get_feature_enabled()) {
2025                 return STT_ERROR_NOT_SUPPORTED;
2026         }
2027
2028         if (NULL == stt || NULL == callback)
2029                 return STT_ERROR_INVALID_PARAMETER;
2030
2031         stt_client_s* client = stt_client_get(stt);
2032
2033         /* check handle */
2034         if (NULL == client) {
2035                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2036                 return STT_ERROR_INVALID_PARAMETER;
2037         }
2038
2039         if (STT_STATE_CREATED != client->current_state) {
2040                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2041                 return STT_ERROR_INVALID_STATE;
2042         }
2043
2044         client->engine_changed_cb = callback;
2045         client->engine_changed_user_data = user_data;
2046
2047         return 0;
2048 }
2049
2050 int stt_unset_engine_changed_cb(stt_h stt)
2051 {
2052         if (0 != __stt_get_feature_enabled()) {
2053                 return STT_ERROR_NOT_SUPPORTED;
2054         }
2055
2056         if (NULL == stt)
2057                 return STT_ERROR_INVALID_PARAMETER;
2058
2059         stt_client_s* client = stt_client_get(stt);
2060
2061         /* check handle */
2062         if (NULL == client) {
2063                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
2064                 return STT_ERROR_INVALID_PARAMETER;
2065         }
2066
2067         if (STT_STATE_CREATED != client->current_state) {
2068                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state);
2069                 return STT_ERROR_INVALID_STATE;
2070         }
2071
2072         client->engine_changed_cb = NULL;
2073         client->engine_changed_user_data = NULL;
2074
2075         return 0;
2076 }