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