common/stt_config_parser.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 <dlog.h>
  15 #include <vconf.h>
  16
  17 #include "stt_defs.h"
  18 #include "stt_config_parser.h"
  19
  20
  21 #define STT_TAG_ENGINE_BASE_TAG         "stt-engine"
  22 #define STT_TAG_ENGINE_NAME             "name"
  23 #define STT_TAG_ENGINE_ID               "id"
  24 #define STT_TAG_ENGINE_SETTING          "setting"
  25 #define STT_TAG_ENGINE_AGREEMENT        "agreement"
  26 #define STT_TAG_ENGINE_LANGUAGE_SET     "languages"
  27 #define STT_TAG_ENGINE_LANGUAGE         "lang"
  28 #define STT_TAG_ENGINE_SILENCE_SUPPORT  "silence-detection-support"
  29
  30 #define STT_TAG_CONFIG_BASE_TAG         "stt-config"
  31 #define STT_TAG_CONFIG_ENGINE_ID        "engine"
  32 #define STT_TAG_CONFIG_ENGINE_SETTING   "engine-setting"
  33 #define STT_TAG_CONFIG_AUTO_LANGUAGE    "auto"
  34 #define STT_TAG_CONFIG_LANGUAGE         "language"
  35 #define STT_TAG_CONFIG_SILENCE_DETECTION "silence-detection"
  36
  37
  38 #define STT_TAG_TIME_BASE_TAG           "stt-time"
  39 #define STT_TAG_TIME_INDEX              "index"
  40 #define STT_TAG_TIME_COUNT              "count"
  41 #define STT_TAG_TIME_TIME_INFO          "time-info"
  42 #define STT_TAG_TIME_TEXT               "text-info"
  43 #define STT_TAG_TIME_START              "start"
  44 #define STT_TAG_TIME_END                "end"
  45
  46 extern const char* stt_tag();
  47
  48 static xmlDocPtr g_config_doc = NULL;
  49
  50 int stt_parser_get_engine_info(const char* path, stt_engine_info_s** engine_info)
  51 {
  52         if (NULL == path || NULL == engine_info) {
  53                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
  54                 return -1;
  55         }
  56
  57         xmlDocPtr doc = NULL;
  58         xmlNodePtr cur = NULL;
  59         xmlChar *key;
  60
  61         doc = xmlParseFile(path);
  62         if (doc == NULL) {
  63                 return -1;
  64         }
  65
  66         cur = xmlDocGetRootElement(doc);
  67         if (cur == NULL) {
  68                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
  69                 xmlFreeDoc(doc);
  70                 return -1;
  71         }
  72
  73         if (xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_BASE_TAG)) {
  74                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT 'stt-engine'");
  75                 xmlFreeDoc(doc);
  76                 return -1;
  77         }
  78
  79         cur = cur->xmlChildrenNode;
  80         if (cur == NULL) {
  81                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
  82                 xmlFreeDoc(doc);
  83                 return -1;
  84         }
  85
  86         /* alloc engine info */
  87         stt_engine_info_s* temp;
  88         temp = (stt_engine_info_s*)calloc(1, sizeof(stt_engine_info_s));
  89         if (NULL == temp) {
  90                 xmlFreeDoc(doc);
  91                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
  92                 return -1;
  93         }
  94
  95         temp->name = NULL;
  96         temp->uuid = NULL;
  97         temp->setting = NULL;
  98         temp->agreement = NULL;
  99         temp->languages = NULL;
 100         temp->support_silence_detection = false;
 101
 102         while (cur != NULL) {
 103                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_NAME)) {
 104                         key = xmlNodeGetContent(cur);
 105                         if (NULL != key) {
 106                                 /* SLOG(LOG_DEBUG, stt_tag(), "Engine name : %s", (char *)key); */
 107                                 if (NULL != temp->name) free(temp->name);
 108                                 temp->name = strdup((char*)key);
 109                                 xmlFree(key);
 110                         } else {
 111                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_NAME);
 112                         }
 113                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_ID)) {
 114                         key = xmlNodeGetContent(cur);
 115                         if (NULL != key) {
 116                                 /* SLOG(LOG_DEBUG, stt_tag(), "Engine uuid : %s", (char *)key); */
 117                                 if (NULL != temp->uuid) free(temp->uuid);
 118                                 temp->uuid = strdup((char*)key);
 119                                 xmlFree(key);
 120                         } else {
 121                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_ID);
 122                         }
 123                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_SETTING)) {
 124                         key = xmlNodeGetContent(cur);
 125                         if (NULL != key) {
 126                                 SLOG(LOG_DEBUG, stt_tag(), "Engine setting : %s", (char *)key);
 127                                 if (NULL != temp->setting)      free(temp->setting);
 128                                 temp->setting = strdup((char*)key);
 129                                 xmlFree(key);
 130                         } else {
 131                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_SETTING);
 132                         }
 133                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_AGREEMENT)) {
 134                         key = xmlNodeGetContent(cur);
 135                         if (NULL != key) {
 136                                 SLOG(LOG_DEBUG, stt_tag(), "Engine agreement : %s", (char *)key);
 137                                 if (NULL != temp->agreement)    free(temp->agreement);
 138                                 temp->agreement = strdup((char*)key);
 139                                 xmlFree(key);
 140                         } else {
 141                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_AGREEMENT);
 142                         }
 143                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_LANGUAGE_SET)) {
 144                         xmlNodePtr lang_node = NULL;
 145                         char* temp_lang = NULL;
 146
 147                         lang_node = cur->xmlChildrenNode;
 148
 149                         while (lang_node != NULL) {
 150                                 if (0 == xmlStrcmp(lang_node->name, (const xmlChar *)STT_TAG_ENGINE_LANGUAGE)) {
 151                                         key = xmlNodeGetContent(lang_node);
 152                                         if (NULL != key) {
 153                                                 /* SLOG(LOG_DEBUG, stt_tag(), "language : %s", (char *)key); */
 154                                                 temp_lang = strdup((char*)key);
 155                                                 temp->languages = g_slist_append(temp->languages, temp_lang);
 156                                                 xmlFree(key);
 157                                         } else {
 158                                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_LANGUAGE);
 159                                         }
 160                                 }
 161
 162                                 lang_node = lang_node->next;
 163                         }
 164                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_ENGINE_SILENCE_SUPPORT)) {
 165                         key = xmlNodeGetContent(cur);
 166                         if (NULL != key) {
 167                                 /*SLOG(LOG_DEBUG, stt_tag(), "silence-detection-support : %s", (char *)key); */
 168
 169                                 if (0 == xmlStrcmp(key, (const xmlChar *)"true"))
 170                                         temp->support_silence_detection = true;
 171                                 else
 172                                         temp->support_silence_detection = false;
 173
 174                                 xmlFree(key);
 175                         } else {
 176                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_ENGINE_SILENCE_SUPPORT);
 177                         }
 178                 } else {
 179
 180                 }
 181
 182                 cur = cur->next;
 183         }
 184
 185         xmlFreeDoc(doc);
 186
 187         if (NULL == temp->name || NULL == temp->uuid) {
 188                 /* Invalid engine */
 189                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] Invalid engine : %s", path);
 190                 stt_parser_free_engine_info(temp);
 191                 return -1;
 192         }
 193
 194         *engine_info = temp;
 195
 196         return 0;
 197 }
 198
 199 int stt_parser_free_engine_info(stt_engine_info_s* engine_info)
 200 {
 201         if (NULL == engine_info) {
 202                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
 203                 return -1;
 204         }
 205
 206         if (NULL != engine_info->name)          free(engine_info->name);
 207         if (NULL != engine_info->uuid)          free(engine_info->uuid);
 208         if (NULL != engine_info->setting)       free(engine_info->setting);
 209         if (NULL != engine_info->agreement)     free(engine_info->agreement);
 210
 211         int count = g_slist_length(engine_info->languages);
 212
 213         int i ;
 214         char *temp_lang;
 215
 216         for (i = 0; i < count ; i++) {
 217                 temp_lang = g_slist_nth_data(engine_info->languages, 0);
 218
 219                 if (NULL != temp_lang) {
 220                         engine_info->languages = g_slist_remove(engine_info->languages, temp_lang);
 221
 222                         if (NULL != temp_lang)
 223                                 free(temp_lang);
 224                 }
 225         }
 226
 227         if (NULL != engine_info)        free(engine_info);
 228
 229         return 0;
 230 }
 231
 232 int stt_parser_print_engine_info(stt_engine_info_s* engine_info)
 233 {
 234         if (NULL == engine_info)
 235                 return -1;
 236
 237         SLOG(LOG_DEBUG, stt_tag(), "== get engine info ==");
 238         SECURE_SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
 239         SECURE_SLOG(LOG_DEBUG, stt_tag(), " id   : %s", engine_info->uuid);
 240         if (NULL != engine_info->setting)       SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
 241
 242         SLOG(LOG_DEBUG, stt_tag(), " languages");
 243         GSList *iter = NULL;
 244         char* lang;
 245         if (g_slist_length(engine_info->languages) > 0) {
 246                 /* Get a first item */
 247                 iter = g_slist_nth(engine_info->languages, 0);
 248
 249                 int i = 1;
 250                 while (NULL != iter) {
 251                         /*Get handle data from list*/
 252                         lang = iter->data;
 253
 254                         SECURE_SLOG(LOG_DEBUG, stt_tag(), "  [%dth] %s", i, lang);
 255
 256                         /*Get next item*/
 257                         iter = g_slist_next(iter);
 258                         i++;
 259                 }
 260         } else {
 261                 SLOG(LOG_ERROR, stt_tag(), "  language is NONE");
 262         }
 263         SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence support : %s", engine_info->support_silence_detection ? "true" : "false");
 264         SLOG(LOG_DEBUG, stt_tag(), "=====================");
 265
 266         return 0;
 267 }
 268
 269 int stt_parser_load_config(stt_config_s** config_info)
 270 {
 271         if (NULL == config_info) {
 272                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
 273                 return -1;
 274         }
 275
 276         xmlDocPtr doc = NULL;
 277         xmlNodePtr cur = NULL;
 278         xmlChar *key;
 279         bool is_default_open = false;
 280
 281         doc = xmlParseFile(STT_CONFIG);
 282         if (doc == NULL) {
 283                 doc = xmlParseFile(STT_DEFAULT_CONFIG);
 284                 if (doc == NULL) {
 285                         SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse file error : %s", STT_DEFAULT_CONFIG);
 286                         return -1;
 287                 }
 288                 is_default_open = true;
 289         }
 290
 291         cur = xmlDocGetRootElement(doc);
 292         if (cur == NULL) {
 293                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 294                 xmlFreeDoc(doc);
 295                 return -1;
 296         }
 297
 298         if (xmlStrcmp(cur->name, (const xmlChar *) STT_TAG_CONFIG_BASE_TAG)) {
 299                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 300                 xmlFreeDoc(doc);
 301                 return -1;
 302         }
 303
 304         cur = cur->xmlChildrenNode;
 305         if (cur == NULL) {
 306                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 307                 xmlFreeDoc(doc);
 308                 return -1;
 309         }
 310
 311         /* alloc engine info */
 312         stt_config_s* temp;
 313         temp = (stt_config_s*)calloc(1, sizeof(stt_config_s));
 314         if (NULL == temp) {
 315                 xmlFreeDoc(doc);
 316                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
 317                 return -1;
 318         }
 319
 320         temp->engine_id = NULL;
 321         temp->setting = NULL;
 322         temp->language = NULL;
 323
 324         while (cur != NULL) {
 325                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_ENGINE_ID)) {
 326                         key = xmlNodeGetContent(cur);
 327                         if (NULL != key) {
 328                                 /*SLOG(LOG_DEBUG, stt_tag(), "Engine id : %s", (char *)key); */
 329                                 if (NULL != temp->engine_id)    free(temp->engine_id);
 330                                 temp->engine_id = strdup((char*)key);
 331                                 xmlFree(key);
 332                         } else {
 333                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] engine id is NULL");
 334                         }
 335                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_ENGINE_SETTING)) {
 336                         key = xmlNodeGetContent(cur);
 337                         if (NULL != key) {
 338                                 /*SECURE_SLOG(LOG_DEBUG, stt_tag(), "Setting path : %s", (char *)key); */
 339                                 if (NULL != temp->setting)      free(temp->setting);
 340                                 temp->setting = strdup((char*)key);
 341                                 xmlFree(key);
 342                         } else {
 343                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] setting path is NULL");
 344                         }
 345
 346                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_AUTO_LANGUAGE)) {
 347                         key = xmlNodeGetContent(cur);
 348                         if (NULL != key) {
 349                                 /*SECURE_SLOG(LOG_DEBUG, stt_tag(), "Auto language : %s", (char *)key); */
 350
 351                                 if (0 == xmlStrcmp(key, (const xmlChar *)"on")) {
 352                                         temp->auto_lang = true;
 353                                 } else if (0 == xmlStrcmp(key, (const xmlChar *)"off")) {
 354                                         temp->auto_lang = false;
 355                                 } else {
 356                                         SLOG(LOG_ERROR, stt_tag(), "Auto voice is wrong");
 357                                         temp->auto_lang = true;
 358                                 }
 359
 360                                 xmlFree(key);
 361                         } else {
 362                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] auto langauge is NULL");
 363                         }
 364                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_LANGUAGE)) {
 365                         key = xmlNodeGetContent(cur);
 366                         if (NULL != key) {
 367                                 /*SLOG(LOG_DEBUG, stt_tag(), "language : %s", (char *)key); */
 368                                 if (NULL != temp->language)     free(temp->language);
 369                                 temp->language = strdup((char*)key);
 370                                 xmlFree(key);
 371                         } else {
 372                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] language is NULL");
 373                         }
 374                 } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_SILENCE_DETECTION)) {
 375                         key = xmlNodeGetContent(cur);
 376                         if (NULL != key) {
 377                                 /*SLOG(LOG_DEBUG, stt_tag(), "silence-detection : %s", (char *)key); */
 378
 379                                 if (0 == xmlStrcmp(key, (const xmlChar *)"on"))
 380                                         temp->silence_detection = true;
 381                                 else
 382                                         temp->silence_detection = false;
 383
 384                                 xmlFree(key);
 385                         } else {
 386                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] silence-detection is NULL");
 387                         }
 388                 } else {
 389
 390                 }
 391
 392                 cur = cur->next;
 393         }
 394
 395         *config_info = temp;
 396         g_config_doc = doc;
 397
 398         if (is_default_open)
 399                 xmlSaveFile(STT_CONFIG, g_config_doc);
 400
 401         return 0;
 402 }
 403
 404 int stt_parser_unload_config(stt_config_s* config_info)
 405 {
 406         if (NULL != g_config_doc)       xmlFreeDoc(g_config_doc);
 407         if (NULL != config_info) {
 408                 if (NULL != config_info->engine_id)     free(config_info->engine_id);
 409                 if (NULL != config_info->setting)       free(config_info->setting);
 410                 if (NULL != config_info->language)      free(config_info->language);
 411
 412                 free(config_info);
 413         }
 414
 415         return 0;
 416 }
 417
 418 int stt_parser_set_engine(const char* engine_id, const char* setting, const char* language, bool silence)
 419 {
 420         if (NULL == g_config_doc || NULL == engine_id)
 421                 return -1;
 422
 423         xmlNodePtr cur = NULL;
 424         cur = xmlDocGetRootElement(g_config_doc);
 425         if (cur == NULL) {
 426                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 427                 return -1;
 428         }
 429
 430         if (xmlStrcmp(cur->name, (const xmlChar *) STT_TAG_CONFIG_BASE_TAG)) {
 431                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 432                 return -1;
 433         }
 434
 435         cur = cur->xmlChildrenNode;
 436         if (cur == NULL) {
 437                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 438                 return -1;
 439         }
 440
 441         while (cur != NULL) {
 442                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_ENGINE_ID)) {
 443                         xmlNodeSetContent(cur, (const xmlChar *)engine_id);
 444                 }
 445
 446                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_LANGUAGE)) {
 447                         xmlNodeSetContent(cur, (const xmlChar *)language);
 448                 }
 449
 450                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_ENGINE_SETTING)) {
 451                         xmlNodeSetContent(cur, (const xmlChar *)setting);
 452                 }
 453
 454                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_SILENCE_DETECTION)) {
 455                         if (true == silence)
 456                                 xmlNodeSetContent(cur, (const xmlChar *)"on");
 457                         else
 458                                 xmlNodeSetContent(cur, (const xmlChar *)"off");
 459                 }
 460
 461                 cur = cur->next;
 462         }
 463
 464         int ret = xmlSaveFile(STT_CONFIG, g_config_doc);
 465         SLOG(LOG_DEBUG, stt_tag(), "Save result : %d", ret);
 466
 467         return 0;
 468 }
 469
 470 int stt_parser_set_language(const char* language)
 471 {
 472         if (NULL == g_config_doc || NULL == language)
 473                 return -1;
 474
 475         xmlNodePtr cur = NULL;
 476         cur = xmlDocGetRootElement(g_config_doc);
 477         if (cur == NULL) {
 478                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 479                 return -1;
 480         }
 481
 482         if (xmlStrcmp(cur->name, (const xmlChar *) STT_TAG_CONFIG_BASE_TAG)) {
 483                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 484                 return -1;
 485         }
 486
 487         cur = cur->xmlChildrenNode;
 488         if (cur == NULL) {
 489                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 490                 return -1;
 491         }
 492
 493         while (cur != NULL) {
 494                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_LANGUAGE)) {
 495                         xmlNodeSetContent(cur, (const xmlChar *)language);
 496                 }
 497
 498                 cur = cur->next;
 499         }
 500
 501         int ret = xmlSaveFile(STT_CONFIG, g_config_doc);
 502         SLOG(LOG_DEBUG, stt_tag(), "Save result : %d", ret);
 503
 504
 505         return 0;
 506 }
 507
 508 int stt_parser_set_auto_lang(bool value)
 509 {
 510         if (NULL == g_config_doc)
 511                 return -1;
 512
 513         xmlNodePtr cur = NULL;
 514         cur = xmlDocGetRootElement(g_config_doc);
 515         if (cur == NULL) {
 516                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 517                 return -1;
 518         }
 519
 520         if (xmlStrcmp(cur->name, (const xmlChar *) STT_TAG_CONFIG_BASE_TAG)) {
 521                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 522                 return -1;
 523         }
 524
 525         cur = cur->xmlChildrenNode;
 526         if (cur == NULL) {
 527                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 528                 return -1;
 529         }
 530
 531         while (cur != NULL) {
 532                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_AUTO_LANGUAGE)) {
 533                         if (true == value) {
 534                                 xmlNodeSetContent(cur, (const xmlChar *)"on");
 535                         } else if (false == value) {
 536                                 xmlNodeSetContent(cur, (const xmlChar *)"off");
 537                         } else {
 538                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong value of auto voice");
 539                                 return -1;
 540                         }
 541                         break;
 542                 }
 543                 cur = cur->next;
 544         }
 545
 546         int ret = xmlSaveFile(STT_CONFIG, g_config_doc);
 547         SLOG(LOG_DEBUG, stt_tag(), "Save result : %d", ret);
 548
 549         return 0;
 550 }
 551
 552 int stt_parser_set_silence_detection(bool value)
 553 {
 554         if (NULL == g_config_doc)
 555                 return -1;
 556
 557         xmlNodePtr cur = NULL;
 558         cur = xmlDocGetRootElement(g_config_doc);
 559         if (cur == NULL) {
 560                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 561                 return -1;
 562         }
 563
 564         if (xmlStrcmp(cur->name, (const xmlChar *) STT_TAG_CONFIG_BASE_TAG)) {
 565                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 566                 return -1;
 567         }
 568
 569         cur = cur->xmlChildrenNode;
 570         if (cur == NULL) {
 571                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 572                 return -1;
 573         }
 574
 575         while (cur != NULL) {
 576                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_CONFIG_SILENCE_DETECTION)) {
 577                         if (true == value)
 578                                 xmlNodeSetContent(cur, (const xmlChar *)"on");
 579                         else
 580                                 xmlNodeSetContent(cur, (const xmlChar *)"off");
 581                 }
 582
 583                 cur = cur->next;
 584         }
 585
 586         int ret = xmlSaveFile(STT_CONFIG, g_config_doc);
 587         SLOG(LOG_DEBUG, stt_tag(), "Save result : %d", ret);
 588
 589         return 0;
 590 }
 591
 592 int stt_parser_find_config_changed(char** engine, char** setting, int* auto_lang, char** language, int* silence)
 593 {
 594         if (NULL == engine || NULL == language || NULL == silence) {
 595                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
 596                 return -1;
 597         }
 598
 599         xmlDocPtr doc = NULL;
 600         xmlNodePtr cur_new = NULL;
 601         xmlNodePtr cur_old = NULL;
 602
 603         xmlChar *key_new;
 604         xmlChar *key_old;
 605
 606         doc = xmlParseFile(STT_CONFIG);
 607         if (doc == NULL) {
 608                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse file error : %s", STT_CONFIG);
 609                 return -1;
 610         }
 611
 612         cur_new = xmlDocGetRootElement(doc);
 613         cur_old = xmlDocGetRootElement(g_config_doc);
 614         if (cur_new == NULL || cur_old == NULL) {
 615                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 616                 xmlFreeDoc(doc);
 617                 return -1;
 618         }
 619
 620         if (xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_BASE_TAG) || xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_BASE_TAG)) {
 621                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT %s", STT_TAG_CONFIG_BASE_TAG);
 622                 xmlFreeDoc(doc);
 623                 return -1;
 624         }
 625
 626         cur_new = cur_new->xmlChildrenNode;
 627         cur_old = cur_old->xmlChildrenNode;
 628         if (cur_new == NULL || cur_old == NULL) {
 629                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 630                 xmlFreeDoc(doc);
 631                 return -1;
 632         }
 633
 634         *engine = NULL;
 635         *setting = NULL;
 636         *language = NULL;
 637
 638         while (cur_new != NULL && cur_old != NULL) {
 639                 if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_ENGINE_ID)) {
 640                         if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_ENGINE_ID)) {
 641                                 key_old = xmlNodeGetContent(cur_old);
 642                                 if (NULL != key_old) {
 643                                         key_new = xmlNodeGetContent(cur_new);
 644                                         if (NULL != key_new) {
 645                                                 if (0 != xmlStrcmp(key_old, key_new)) {
 646                                                         SECURE_SLOG(LOG_DEBUG, stt_tag(), "Old engine id(%s), New engine(%s)", (char*)key_old, (char*)key_new);
 647                                                         if (NULL != *engine)    free(*engine);
 648                                                         *engine = strdup((char*)key_new);
 649                                                 }
 650                                                 xmlFree(key_new);
 651                                         }
 652                                         xmlFree(key_old);
 653                                 }
 654                         } else {
 655                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Old config and new config are different");
 656                         }
 657                 } else if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_ENGINE_SETTING)) {
 658                         if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_ENGINE_SETTING)) {
 659                                 key_old = xmlNodeGetContent(cur_old);
 660                                 if (NULL != key_old) {
 661                                         key_new = xmlNodeGetContent(cur_new);
 662                                         if (NULL != key_new) {
 663                                                 if (0 != xmlStrcmp(key_old, key_new)) {
 664                                                         SLOG(LOG_DEBUG, stt_tag(), "Old engine setting(%s), New engine setting(%s)", (char*)key_old, (char*)key_new);
 665                                                         if (NULL != *setting)   free(*setting);
 666                                                         *setting = strdup((char*)key_new);
 667                                                 }
 668                                                 xmlFree(key_new);
 669                                         }
 670                                         xmlFree(key_old);
 671                                 }
 672                         } else {
 673                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Old config and new config are different");
 674                         }
 675                 } else if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_AUTO_LANGUAGE)) {
 676                         if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_AUTO_LANGUAGE)) {
 677                                 key_old = xmlNodeGetContent(cur_old);
 678                                 if (NULL != key_old) {
 679                                         key_new = xmlNodeGetContent(cur_new);
 680                                         if (NULL != key_new) {
 681                                                 if (0 != xmlStrcmp(key_old, key_new)) {
 682                                                         SLOG(LOG_DEBUG, stt_tag(), "Old auto lang(%s), New auto lang(%s)", (char*)key_old, (char*)key_new);
 683                                                         if (0 == xmlStrcmp((const xmlChar*)"on", key_new)) {
 684                                                                 *auto_lang = (int)true;
 685                                                         } else {
 686                                                                 *auto_lang = (int)false;
 687                                                         }
 688                                                 }
 689
 690                                                 xmlFree(key_new);
 691                                         }
 692                                         xmlFree(key_old);
 693                                 }
 694                         } else {
 695                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] old config and new config are different");
 696                         }
 697                 } else if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_LANGUAGE)) {
 698                         if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_LANGUAGE)) {
 699                                 key_old = xmlNodeGetContent(cur_old);
 700                                 if (NULL != key_old) {
 701                                         key_new = xmlNodeGetContent(cur_new);
 702                                         if (NULL != key_new) {
 703                                                 if (0 != xmlStrcmp(key_old, key_new)) {
 704                                                         SECURE_SLOG(LOG_DEBUG, stt_tag(), "Old language(%s), New language(%s)", (char*)key_old, (char*)key_new);
 705                                                         if (NULL != *language)  free(*language);
 706                                                         *language = strdup((char*)key_new);
 707                                                 }
 708                                                 xmlFree(key_new);
 709                                         }
 710                                         xmlFree(key_old);
 711                                 }
 712                         } else {
 713                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] old config and new config are different");
 714                         }
 715                 } else if (0 == xmlStrcmp(cur_new->name, (const xmlChar*)STT_TAG_CONFIG_SILENCE_DETECTION)) {
 716                         if (0 == xmlStrcmp(cur_old->name, (const xmlChar*)STT_TAG_CONFIG_SILENCE_DETECTION)) {
 717                                 key_old = xmlNodeGetContent(cur_old);
 718                                 if (NULL != key_old) {
 719                                         key_new = xmlNodeGetContent(cur_new);
 720                                         if (NULL != key_new) {
 721                                                 if (0 != xmlStrcmp(key_old, key_new)) {
 722                                                         SECURE_SLOG(LOG_DEBUG, stt_tag(), "Old silence(%s), New silence(%s)", (char*)key_old, (char*)key_new);
 723                                                         if (0 == xmlStrcmp(key_new, (const xmlChar*)"on")) {
 724                                                                 *silence = 1;
 725                                                         } else {
 726                                                                 *silence = 0;
 727                                                         }
 728                                                 }
 729
 730                                                 xmlFree(key_new);
 731                                         }
 732                                         xmlFree(key_old);
 733                                 }
 734                         } else {
 735                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] old config and new config are different");
 736                         }
 737                 } else {
 738
 739                 }
 740
 741                 cur_new = cur_new->next;
 742                 cur_old = cur_old->next;
 743         }
 744
 745         xmlFreeDoc(g_config_doc);
 746         g_config_doc = doc;
 747
 748         return 0;
 749 }
 750
 751 /**
 752 * time function
 753 */
 754
 755 int stt_parser_set_time_info(GSList* time_list)
 756 {
 757         if (0 == g_slist_length(time_list)) {
 758                 SLOG(LOG_WARN, stt_tag(), "[WARNING] There is no time info to save");
 759                 return -1;
 760         }
 761
 762         if (-1 == remove(STT_TIME_INFO_PATH)) {
 763                 SECURE_SLOG(LOG_WARN, stt_tag(), "[PLAYER WARNING] Fail to remove file(%s)", STT_TIME_INFO_PATH);
 764         }
 765
 766         xmlDocPtr doc = NULL;
 767         xmlNodePtr cur = NULL;
 768
 769         doc = xmlNewDoc((const xmlChar*)"1.0");
 770         if (doc == NULL) {
 771                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make new doc");
 772                 return -1;
 773         }
 774
 775         cur = xmlNewNode(NULL, (const xmlChar*)STT_TAG_TIME_BASE_TAG);
 776         xmlDocSetRootElement(doc, cur);
 777
 778         xmlNodePtr inode = NULL;
 779         GSList *iter = NULL;
 780         stt_result_time_info_s *data = NULL;
 781         char temp_str[256];
 782
 783         snprintf(temp_str, 256, "%d", g_slist_length(time_list));
 784
 785         inode = xmlNewNode(NULL, (const xmlChar*)STT_TAG_TIME_INDEX);
 786         xmlNewProp(inode, (const xmlChar*)STT_TAG_TIME_COUNT, (const xmlChar*)temp_str);
 787         xmlAddChild(cur, inode);
 788
 789         /* Get a first item */
 790         iter = g_slist_nth(time_list, 0);
 791         while (NULL != iter) {
 792                 data = iter->data;
 793
 794                 xmlNodePtr temp_node = NULL;
 795
 796                 SLOG(LOG_DEBUG, stt_tag(), "[%d] i(%d) t(%s) s(%d) e(%d)",
 797                          data->index, data->event, data->text, data->start_time, data->end_time);
 798
 799                 temp_node = xmlNewNode(NULL, (const xmlChar*)STT_TAG_TIME_TEXT);
 800                 xmlNodeSetContent(temp_node, (const xmlChar*)data->text);
 801                 xmlAddChild(inode, temp_node);
 802
 803                 temp_node = xmlNewNode(NULL, (const xmlChar*)STT_TAG_TIME_START);
 804                 snprintf(temp_str, 256, "%ld", data->start_time);
 805                 xmlNodeSetContent(temp_node, (const xmlChar*)temp_str);
 806                 xmlAddChild(inode, temp_node);
 807
 808                 temp_node = xmlNewNode(NULL, (const xmlChar*)STT_TAG_TIME_END);
 809                 snprintf(temp_str, 256, "%ld", data->end_time);
 810                 xmlNodeSetContent(temp_node, (const xmlChar*)temp_str);
 811                 xmlAddChild(inode, temp_node);
 812
 813                 /*Get next item*/
 814                 iter = g_slist_next(iter);
 815         }
 816
 817         int ret = xmlSaveFormatFile(STT_TIME_INFO_PATH, doc, 1);
 818         SLOG(LOG_DEBUG, stt_tag(), "Save result : %d", ret);
 819
 820         xmlFreeDoc(doc);
 821         return 0;
 822 }
 823
 824 int stt_parser_get_time_info(GSList** time_list)
 825 {
 826         if (NULL == time_list) {
 827                 SLOG(LOG_ERROR, stt_tag(), "Invalid paramter : text is NULL");
 828                 return -1;
 829         }
 830
 831         xmlDocPtr doc = NULL;
 832         xmlNodePtr cur = NULL;
 833
 834         doc = xmlParseFile(STT_TIME_INFO_PATH);
 835         if (doc == NULL) {
 836                 SLOG(LOG_WARN, stt_tag(), "[WARNING] File is not exist");
 837                 return -1;
 838         }
 839
 840         cur = xmlDocGetRootElement(doc);
 841         if (cur == NULL) {
 842                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 843                 xmlFreeDoc(doc);
 844                 return -1;
 845         }
 846
 847         if (xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_TIME_BASE_TAG)) {
 848                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] The wrong type, root node is NOT '%s'", STT_TAG_TIME_BASE_TAG);
 849                 xmlFreeDoc(doc);
 850                 return -1;
 851         }
 852
 853         cur = cur->xmlChildrenNode;
 854         if (cur == NULL) {
 855                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty document");
 856                 xmlFreeDoc(doc);
 857                 return -1;
 858         }
 859
 860         /* alloc time info */
 861         GSList *temp_time_list = NULL;
 862         xmlChar *key = NULL;
 863         int index = 0;
 864
 865         while (cur != NULL) {
 866                 if (0 == xmlStrcmp(cur->name, (const xmlChar *)STT_TAG_TIME_INDEX)) {
 867                         key = xmlGetProp(cur, (const xmlChar*)STT_TAG_TIME_COUNT);
 868                         if (NULL == key) {
 869                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_TIME_COUNT);
 870                                 return -1;
 871                         }
 872
 873                         SLOG(LOG_DEBUG, stt_tag(), "Count : %s", (char *)key);
 874
 875                         /* Get time count */
 876                         int count = 0;
 877                         count = atoi((char*)key);
 878                         xmlFree(key);
 879
 880                         if (count <= 0) {
 881                                 SLOG(LOG_ERROR, stt_tag(), "[ERROR] count is invalid : %d", count);
 882                                 break;
 883                         }
 884
 885                         xmlNodePtr time_node = NULL;
 886                         time_node = cur->xmlChildrenNode;
 887
 888                         int i = 0;
 889                         for (i = 0; i < count; i++) {
 890                                 /* text */
 891                                 time_node = time_node->next;
 892
 893                                 stt_result_time_info_s* temp_info;
 894                                 temp_info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
 895
 896                                 if (NULL == temp_info) {
 897                                         SLOG(LOG_ERROR, stt_tag(), "[ERROR] Memory alloc error!!");
 898                                         return -1;
 899                                 }
 900
 901                                 temp_info->index = index;
 902                                 SLOG(LOG_DEBUG, stt_tag(), "index : %d", temp_info->index);
 903
 904                                 if (0 == i)             temp_info->event = 0;
 905                                 else if (count -1 == i) temp_info->event = 2;
 906                                 else                    temp_info->event = 1;
 907
 908                                 if (0 == xmlStrcmp(time_node->name, (const xmlChar *)STT_TAG_TIME_TEXT)) {
 909                                         key = xmlNodeGetContent(time_node);
 910                                         if (NULL != key) {
 911                                                 SLOG(LOG_DEBUG, stt_tag(), "text : %s", (char *)key);
 912                                                 temp_info->text = strdup((char*)key);
 913                                                 xmlFree(key);
 914                                         } else {
 915                                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_TIME_TEXT);
 916                                                 free(temp_info);
 917                                                 break;
 918                                         }
 919                                 }
 920
 921                                 /* text */
 922                                 time_node = time_node->next;
 923                                 time_node = time_node->next;
 924
 925                                 if (0 == xmlStrcmp(time_node->name, (const xmlChar *)STT_TAG_TIME_START)) {
 926                                         key = xmlNodeGetContent(time_node);
 927                                         if (NULL != key) {
 928                                                 SLOG(LOG_DEBUG, stt_tag(), "Start time : %s", (char *)key);
 929                                                 temp_info->start_time = atoi((char*)key);
 930                                                 xmlFree(key);
 931                                         } else {
 932                                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_TIME_START);
 933                                                 if (NULL != temp_info->text)    free(temp_info->text);
 934                                                 free(temp_info);
 935                                                 break;
 936                                         }
 937                                 }
 938
 939                                 /* text */
 940                                 time_node = time_node->next;
 941                                 time_node = time_node->next;
 942
 943                                 if (0 == xmlStrcmp(time_node->name, (const xmlChar *)STT_TAG_TIME_END)) {
 944                                         key = xmlNodeGetContent(time_node);
 945                                         if (NULL != key) {
 946                                                 SLOG(LOG_DEBUG, stt_tag(), "End time : %s", (char *)key);
 947                                                 temp_info->end_time = atoi((char*)key);
 948                                                 xmlFree(key);
 949                                         } else {
 950                                                 SECURE_SLOG(LOG_ERROR, stt_tag(), "[ERROR] <%s> has no content", STT_TAG_TIME_END);
 951                                                 if (NULL != temp_info->text)    free(temp_info->text);
 952                                                 free(temp_info);
 953                                                 break;
 954                                         }
 955                                 }
 956
 957                                 time_node = time_node->next;
 958
 959                                 temp_time_list = g_slist_append(temp_time_list, temp_info);
 960                         } /* for */
 961                         index++;
 962                 } /* if */
 963                 cur = cur->next;
 964         }
 965
 966         xmlFreeDoc(doc);
 967
 968         *time_list = temp_time_list;
 969
 970         return 0;
 971 }
 972
 973 int stt_parser_clear_time_info()
 974 {
 975         if (-1 == remove(STT_TIME_INFO_PATH)) {
 976                 SECURE_SLOG(LOG_WARN, stt_tag(), "[PLAYER WARNING] Fail to remove file(%s)", STT_TIME_INFO_PATH);
 977         }
 978
 979         return 0;
 980 }