src/w-input-stt-voice.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <Elementary.h>
  19 #include <Ecore_IMF.h>
  20 #include <Ecore.h>
  21 #include <device/power.h>
  22 #include <efl_assist.h>
  23 #include <app_common.h>
  24 #include <app.h>
  25 #include <string>
  26 #include <efl_extension.h>
  27 #include <feedback.h>
  28
  29 #include "Debug.h"
  30 #include "w-input-selector.h"
  31 #include "w-input-smartreply.h"
  32 #include "w-input-stt-voice.h"
  33 #include "w-input-stt-engine.h"
  34 #include "w-input-stt-ise.h"
  35
  36 using namespace std;
  37
  38 #define _EDJ(x)  elm_layout_edje_get(x)
  39
  40
  41 #define GRP_PORTRAIT "mic_control"
  42
  43 #define item_append(obj, style, index, cb, udata) \
  44                 elm_genlist_item_append(obj, &(style), (void *)index, NULL, ELM_GENLIST_ITEM_NONE, cb, udata)
  45
  46 #define VIRTUAL_TEXT_AREA_FONT_STYLE \
  47                 "DEFAULT='font=Tizen:style=Regular  font_size=32 color=#FFFFFF color_class=AT013 text_class=tizen wrap=mixed align=center' \
  48                 newline='br' b='+ font=Tizen:style=Bold'link='+ underline=on underline_color=#FFFFFF'"
  49
  50 extern App_Data* app_data;
  51 extern VoiceData *my_voicedata;
  52
  53 static bool power_state = false;
  54
  55 static bool bottom_button_access_state = false;
  56
  57 static Evas_Object *radio_gp = NULL;
  58 Evas_Object *g_setting_window = NULL;
  59 static Evas_Object *g_setting_naviframe = NULL;
  60 static Evas_Object *g_more_option_layout = NULL;
  61
  62 static Ecore_Event_Handler *g_evt_key_down = NULL;
  63
  64 static bool g_is_n66 = true;
  65
  66 static Elm_Genlist_Item_Class itc_title;
  67 static Elm_Genlist_Item_Class itc_1text;
  68 static Elm_Genlist_Item_Class itc_2text;
  69
  70 static bool g_send_button_clicked = false;
  71 //accessbility
  72 static bool g_mic_clicked = false;
  73
  74 static void set_guide_text(VoiceData *vd, const char* text, bool translatable = false);
  75
  76 char *supported_language[13] = {
  77                 "auto",
  78                 "de_DE",
  79                 "en_GB",
  80                 "en_US",
  81                 "es_ES",
  82                 "es_US",
  83                 "fr_FR",
  84                 "it_IT",
  85                 "pt_BR",
  86                 "ru_RU",
  87                 "zh_CN",
  88                 "ja_JP",
  89                 "ko_KR",
  90 };
  91
  92 char *supported_language_n66[7] = {
  93                 "auto",
  94                 "en_US",
  95                 "es_US",
  96                 "fr_FR",
  97                 "zh_CN",
  98                 "ja_JP",
  99                 "ko_KR",
 100 };
 101
 102
 103 char *disp_lang_array[13] = {
 104                 "",
 105                 "Deutsch",
 106                 "English (United Kingdom)",
 107                 "English (United States)",
 108                 "Español (España)",
 109                 "Español (América Latina)",
 110                 "Français (France)",
 111                 "Italiano",
 112                 "Português (Brasil)",
 113                 "Pусский",
 114                 "简体中文",
 115                 "日本語",
 116                 "한국어",
 117 };
 118
 119 char *disp_lang_array_n66[7] = {
 120                 "",
 121                 "English (United States)",
 122                 "Español (América Latina)",
 123                 "Français (France)",
 124                 "简体中文",
 125                 "日本語",
 126                 "한국어",
 127 };
 128
 129
 130 typedef enum {
 131         STT_VOICE_AUTO,
 132         STT_VOICE_DE_DE,
 133         STT_VOICE_EN_GB,
 134         STT_VOICE_EN_US,
 135         STT_VOICE_ES_ES,
 136         STT_VOICE_ES_US,
 137         STT_VOICE_FR_FR,
 138         STT_VOICE_IT_IT,
 139         STT_VOICE_PT_BR,
 140         STT_VOICE_RU_RU,
 141         STT_VOICE_ZH_CN,
 142         STT_VOICE_JA_JP,
 143         STT_VOICE_KO_KR
 144 }STT_VOICE_LANGUAGE_I;
 145
 146 typedef enum {
 147         STT_VOICE_N66_AUTO,
 148         STT_VOICE_N66_EN_US,
 149         STT_VOICE_N66_ES_US,
 150         STT_VOICE_N66_FR_FR,
 151         STT_VOICE_N66_ZH_CN,
 152         STT_VOICE_N66_JA_JP,
 153         STT_VOICE_N66_KO_KR
 154 }STT_VOICE_LANGUAGE_N66_I;
 155
 156 typedef enum {
 157         BEEP_SOUND_START,
 158         BEEP_SOUND_STOP,
 159         VIBRATION_START,
 160         VIBRATION_STOP,
 161         BEEP_SOUND_TOUCH,
 162         WAKEUP_COMMAND,
 163 }FeedbackType;
 164
 165 static void get_stt_default_language(VoiceData *my_voicedata);
 166
 167
 168 char* get_lang_label(char lang[])
 169 {
 170         char *str = NULL;
 171
 172         if (strcmp(lang, "en_US") == 0)
 173                 str = disp_lang_array[3];
 174
 175         else if (strcmp(lang, "ko_KR") == 0)
 176                 str = disp_lang_array[12];
 177
 178         else if (strcmp(lang, "de_DE") == 0)
 179                 str = disp_lang_array[1];
 180
 181         else if (strcmp(lang, "fr_FR") == 0)
 182                 str = disp_lang_array[6];
 183
 184         else if (strcmp(lang, "it_IT") == 0)
 185                 str = disp_lang_array[7];
 186
 187         else if (strcmp(lang, "en_GB") == 0)
 188                 str = disp_lang_array[2];
 189
 190         else if (strcmp(lang, "ja_JP") == 0)
 191                 str = disp_lang_array[11];
 192
 193         else if (strcmp(lang, "zh_CN") == 0)
 194                 str = disp_lang_array[10];
 195
 196         else if (strcmp(lang, "ru_RU") == 0)
 197                 str = disp_lang_array[9];
 198
 199         else if (strcmp(lang, "pt_BR") == 0)
 200                 str = disp_lang_array[8];
 201
 202         else if (strcmp(lang, "es_ES") == 0)
 203                 str = disp_lang_array[4];
 204
 205         else if (strcmp(lang, "es_US") == 0)
 206                 str = disp_lang_array[5];
 207
 208         else
 209                 str = disp_lang_array[3];
 210
 211         return str;
 212 }
 213
 214 char* get_lang_label_n66(char lang[])
 215 {
 216         char *str = NULL;
 217
 218         if (strcmp (lang, "en_US") == 0)
 219                 str = disp_lang_array_n66[1];
 220
 221         else if (strcmp (lang, "ko_KR") == 0)
 222                 str = disp_lang_array_n66[6];
 223
 224         else if (strcmp (lang, "fr_FR") == 0)
 225                 str = disp_lang_array_n66[3];
 226
 227         else if (strcmp (lang, "ja_JP") == 0)
 228                 str = disp_lang_array_n66[5];
 229
 230         else if (strcmp (lang, "zh_CN") == 0)
 231                 str = disp_lang_array_n66[4];
 232
 233         else if (strcmp (lang, "es_US") == 0)
 234                 str = disp_lang_array_n66[2];
 235
 236         else
 237                 str = disp_lang_array_n66[1];
 238
 239         return str;
 240 }
 241
 242
 243 static Eina_Bool
 244 _bring_in_cb(void *data)
 245 {
 246         if(!data)
 247                 return ECORE_CALLBACK_CANCEL;
 248
 249         Evas_Coord x, y, w, h;
 250
 251         Evas_Object *scroller = (Evas_Object *)data;
 252         Evas_Object *inner_layout = NULL;
 253
 254         inner_layout = (Evas_Object *) evas_object_data_get(scroller, "inner_layout");
 255
 256         evas_object_geometry_get(inner_layout, &x, &y, &w, &h);
 257         elm_scroller_region_bring_in(scroller, x, h, w, h);
 258
 259         PRINTFUNC(NO_PRINT, "scroller %d %d %d %d", x, y, w, h);
 260
 261         return ECORE_CALLBACK_CANCEL;
 262 }
 263
 264 static inline Evas_Coord get_text_block_size(Evas_Object *obj, std::string text)
 265 {
 266         int calculated_height = 0;
 267
 268         int max_height = 1280;
 269         int unit_width = 282;
 270
 271         Evas_Coord width, height;
 272
 273         char *strbuf = NULL;
 274         Evas_Object *tb = NULL;
 275         Evas_Textblock_Style *st = NULL;
 276         Evas_Textblock_Cursor *cur = NULL;
 277
 278         tb = evas_object_textblock_add(evas_object_evas_get(obj));
 279         evas_object_textblock_legacy_newline_set(tb, EINA_FALSE);
 280
 281         st = evas_textblock_style_new();
 282         evas_textblock_style_set(st, VIRTUAL_TEXT_AREA_FONT_STYLE);
 283         evas_object_textblock_style_set(tb, st);
 284
 285         cur = evas_object_textblock_cursor_new(tb);
 286         strbuf = elm_entry_utf8_to_markup(text.c_str());
 287         evas_object_resize(tb, unit_width, max_height);
 288
 289         evas_object_textblock_text_markup_set(tb, strbuf);
 290         evas_textblock_cursor_format_prepend(cur, "+ wrap=mixed");
 291     evas_object_textblock_size_formatted_get(tb, &width, &height);
 292         evas_object_resize(tb, unit_width, height);
 293
 294         if(strbuf) free(strbuf);
 295         if(tb) evas_object_del(tb);
 296         if(st) evas_textblock_style_free(st);
 297         if(cur) evas_textblock_cursor_free(cur);
 298
 299         return height;
 300 }
 301
 302 static Eina_Bool _update_textblock_timer_cb(void *data)
 303 {
 304         if(!data)
 305                 return ECORE_CALLBACK_CANCEL;
 306
 307         VoiceData* voicedata = (VoiceData*)data;
 308
 309         voicedata->textblock_timer = NULL;
 310
 311         std::string result_text;
 312         for(int i = 0; i < voicedata->stt_results.size(); i++){
 313                 if(i == voicedata->stt_results.size()-1){
 314                         result_text += voicedata->stt_results.at(i);
 315                 } else {
 316                         result_text += voicedata->stt_results.at(i);
 317                         result_text += " ";
 318                 }
 319         }
 320
 321         Evas_Object *rect = NULL;
 322         Evas_Object *entry = NULL;
 323         Evas_Object *scroller = NULL;
 324         Evas_Object *box = NULL;
 325         Evas_Object *inner_layout = NULL;
 326         char *strbuf = NULL;
 327
 328         scroller = elm_layout_content_get((Evas_Object *)voicedata->layout_main, "text_area");
 329         if(!scroller)
 330         {
 331                 PRINTFUNC(DLOG_ERROR, "failed to get scroller");
 332                 return ECORE_CALLBACK_CANCEL;
 333         }
 334
 335         box = elm_object_content_get(scroller);
 336         if(!box)
 337         {
 338                 PRINTFUNC(DLOG_ERROR, "failed to get box");
 339                 return ECORE_CALLBACK_CANCEL;
 340         }
 341
 342         inner_layout = (Evas_Object *) evas_object_data_get(scroller, "inner_layout");
 343         if(!inner_layout)
 344         {
 345                 PRINTFUNC(DLOG_ERROR, "failed to get inner_layout");
 346                 return ECORE_CALLBACK_CANCEL;
 347         }
 348
 349         entry = elm_layout_content_get(inner_layout, "elm.swallow.content");
 350         if(!entry)
 351         {
 352                 PRINTFUNC(DLOG_ERROR, "failed to get entry");
 353                 return ECORE_CALLBACK_CANCEL;
 354         }
 355
 356         Evas_Object *top = (Evas_Object *) evas_object_data_get(box, "top_padding");
 357         Evas_Object *bottom = (Evas_Object *) evas_object_data_get(box, "bottom_padding");
 358
 359         if(top) {
 360                 elm_box_unpack(box, top);
 361                 evas_object_del(top);
 362                 top = NULL;
 363         }
 364         if(bottom) {
 365                 elm_box_unpack(box, bottom);
 366                 evas_object_del(bottom);
 367                 bottom = NULL;
 368         }
 369
 370         Evas_Coord height = get_text_block_size(box, result_text);
 371
 372 //      if(height < 173) {
 373         {
 374                 int text_area_height = 360-102; // screen H - bottom button H
 375                 int top_height = ((text_area_height - height) / 2);
 376                 if(top_height < 120) top_height = 120; // Top fade area H
 377
 378                 int bottom_height = (text_area_height - top_height - height);
 379                 if(bottom_height < 1) bottom_height = 0;
 380
 381                 PRINTFUNC(SECURE_DEBUG, "str : %s", result_text.c_str());
 382                 PRINTFUNC(DLOG_DEBUG, "height : %d", height);
 383                 PRINTFUNC(DLOG_DEBUG, "top_height : %d", top_height);
 384                 PRINTFUNC(DLOG_DEBUG, "bottom_height : %d", bottom_height);
 385
 386                 rect = evas_object_rectangle_add(evas_object_evas_get(box));
 387                 evas_object_color_set(rect, 0, 0, 0, 100);
 388                 evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 389                 evas_object_size_hint_min_set(rect, 282, top_height);
 390                 evas_object_show(rect);
 391
 392                 elm_box_pack_before(box, rect, inner_layout);
 393                 evas_object_data_set(box, "top_padding", (void *) rect);
 394
 395                 rect = evas_object_rectangle_add(evas_object_evas_get(box));
 396                 evas_object_color_set(rect, 0, 0, 0, 100);
 397                 evas_object_size_hint_weight_set(rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 398                 evas_object_size_hint_min_set(rect, 282, bottom_height);
 399                 evas_object_show(rect);
 400
 401                 elm_box_pack_end(box, rect);
 402                 evas_object_data_set(box, "bottom_padding", (void *) rect);
 403         }
 404
 405         elm_entry_entry_set(entry, result_text.c_str());
 406
 407         Evas_Object *panel_layout = elm_layout_content_get((Evas_Object *)voicedata->layout_main, "left_panel_area");
 408         Evas_Object *panel_left = elm_layout_content_get((Evas_Object *)panel_layout, "elm.swallow.right");
 409
 410         if (result_text.size() > 0) {
 411                 elm_object_signal_emit(panel_left, "elm,state,enabled", "elm");
 412         } else {
 413                 elm_object_signal_emit(panel_left, "elm,state,disabled", "elm");
 414         }
 415
 416         elm_object_signal_emit((Evas_Object *)voicedata->layout_main, "idle,state,guide_text,bottom", "elm");
 417
 418         if(voicedata->state == STT_STATE_VAL_LISTENING){
 419                 if(voicedata->guide_text_timer != NULL){
 420                         PRINTFUNC(DLOG_DEBUG, "Skip hide_guide_text");
 421                         ecore_timer_del(voicedata->guide_text_timer);
 422                         voicedata->guide_text_timer = NULL;
 423                 }
 424                 set_guide_text(voicedata, SK_TAP_TO_PAUSE, true);
 425         }
 426
 427         elm_object_signal_emit(inner_layout, "scrolling", "entry");
 428
 429         return ECORE_CALLBACK_CANCEL;
 430 }
 431
 432 void _update_textblock(void *data)
 433 {
 434         if(!data)
 435                 return;
 436
 437         VoiceData *voicedata = (VoiceData *) data;
 438
 439         if(voicedata->textblock_timer == NULL){
 440                 voicedata->textblock_timer = ecore_timer_add(1.0, _update_textblock_timer_cb, voicedata);
 441         } else {
 442                 PRINTFUNC(DLOG_DEBUG, "skip : the timer is not expired.");
 443         }
 444
 445         return;
 446 }
 447
 448 void voice_get_string(const char *keyValue, _VoiceData *voicedata)
 449 {
 450         if(!voicedata)
 451                 return;
 452
 453         char* strbuf = NULL;
 454
 455         strbuf = elm_entry_utf8_to_markup(keyValue);
 456
 457         PRINTFUNC(DLOG_DEBUG, "text : %s, voicedata->partial_result=%s", strbuf, voicedata->partial_result);
 458
 459         if(strbuf){
 460                 if(voicedata->partial_result){ // partial_result is not Null so replace
 461                         if(strcmp(voicedata->partial_result, strbuf)){
 462                                 // different replace
 463                                 PRINTFUNC(DLOG_DEBUG, "different replace");
 464
 465                                 voicedata->stt_results.pop_back();
 466                                 voicedata->stt_results.push_back(strbuf);
 467
 468                                 free(voicedata->partial_result);
 469                                 voicedata->partial_result = strdup(strbuf);
 470                         }
 471                 } else { // partial_result is Null so first case
 472                         PRINTFUNC(DLOG_DEBUG, "first push");
 473                         voicedata->stt_results.push_back(strbuf);
 474                         voicedata->partial_result = strdup(strbuf);
 475                 }
 476         }
 477
 478         _update_textblock(voicedata);
 479
 480         if(strbuf)
 481                 free(strbuf);
 482
 483         PRINTFUNC(DLOG_DEBUG, "ends");
 484 }
 485
 486 static Eina_Bool _recognition_failure_cb(void *data)
 487 {
 488         if(data) {
 489                 VoiceData *voicedata = (VoiceData *) data;
 490
 491                 voicedata->state = STT_STATE_VAL_INIT;
 492                 set_animation_state(voicedata);
 493                 voicedata->refresh_timer = NULL;
 494         }
 495         return ECORE_CALLBACK_CANCEL;
 496 }
 497
 498 void start_by_press(VoiceData *voicedata)
 499 {
 500         PRINTFUNC(DLOG_DEBUG, "");
 501
 502         edje_object_signal_emit(_EDJ(voicedata->layout_main), "mouse,clicked,1", "background");
 503
 504         return;
 505 }
 506
 507 static void on_mic_button_press_cb(void *data, Evas_Object *obj, void *event_info)
 508 {
 509         PRINTFUNC(NO_PRINT, "");
 510
 511         VoiceData *voicedata = (VoiceData *)data;
 512
 513         if (elm_config_access_get()){
 514                 if(bottom_button_access_state == true){
 515                         PRINTFUNC(DLOG_DEBUG, "skip until bottom buttom is being read by accessibility");
 516                         return;
 517                 }
 518         }
 519
 520         edje_object_signal_emit(_EDJ(voicedata->layout_main), "mouse,clicked,1", "background");
 521
 522         return;
 523 }
 524
 525 static char *_left_cue_access_info_cb(void *data, Evas_Object *obj)
 526 {
 527    char text[512];
 528
 529    snprintf(text, sizeof(text), "%s, %s", gettext(TTS_SEND), gettext(TTS_BUTTON));
 530
 531    return strdup(text);
 532 }
 533
 534 static void _left_cue_access_activate_cb(void * data, Evas_Object *part_obj, Elm_Object_Item *item)
 535 {
 536     Evas_Object *obj = (Evas_Object *)data;
 537     elm_layout_signal_emit(obj, "cue,clicked", "elm");
 538
 539     elm_panel_toggle(obj);
 540 }
 541
 542
 543 static void _send_button_highlighted_cb(void *data, Evas_Object * obj, void *event_info)
 544 {
 545         PRINTFUNC(DLOG_DEBUG, "");
 546         VoiceData* voicedata = (VoiceData*)data;
 547
 548         if (voicedata->sttmanager->GetCurrent() == STT_STATE_RECORDING ||
 549          voicedata->sttmanager->GetCurrent() == STT_STATE_PROCESSING)
 550                 return;
 551
 552         std::string text = std::string(gettext(TTS_SEND));
 553         text = text +" "+ gettext(TTS_BUTTON);
 554         if (elm_object_disabled_get(obj))
 555                 text = text + " " + gettext(TTS_DISABLED);
 556
 557         elm_access_say(text.c_str());
 558 }
 559
 560 static Eina_Bool _mic_button_enable_cb(void *data)
 561 {
 562         PRINTFUNC(DLOG_DEBUG, "");
 563
 564         if(!data)
 565                 return ECORE_CALLBACK_CANCEL;
 566
 567         VoiceData* voicedata = (VoiceData*)data;
 568
 569         voicedata->btn_disabling_timer = NULL;
 570
 571         Evas_Object *button = (Evas_Object *)voicedata->mic_button;
 572
 573         elm_object_disabled_set(button, EINA_FALSE);
 574
 575         if (elm_config_access_get()){
 576                 bottom_button_access_state = false;
 577         }
 578
 579         return ECORE_CALLBACK_CANCEL;
 580 }
 581
 582 static void _mic_highlighted_cb(void *data, Evas_Object * obj, void *event_info)
 583 {
 584         PRINTFUNC(DLOG_DEBUG, "");
 585         VoiceData* voicedata = (VoiceData*)data;
 586
 587         if (voicedata->sttmanager->GetCurrent() == STT_STATE_RECORDING ||
 588         voicedata->sttmanager->GetCurrent() == STT_STATE_PROCESSING)
 589            return;
 590
 591
 592         if (elm_config_access_get()){
 593                 bottom_button_access_state = true;
 594         } else {
 595                 elm_object_disabled_set(voicedata->mic_button, EINA_TRUE);
 596         }
 597
 598
 599         if(voicedata->btn_disabling_timer == NULL){
 600                 ecore_timer_del(voicedata->btn_disabling_timer);
 601         }
 602         voicedata->btn_disabling_timer = ecore_timer_add(3.0, _mic_button_enable_cb, voicedata);
 603
 604         elm_access_say(gettext(SK_DOUBLE_TAP_TO_SPEAK));
 605 }
 606
 607 static char *_mic_access_info_cb(void *data, Evas_Object *obj)
 608 {
 609         if (data) return strdup((const char*)data);
 610         return NULL;
 611 }
 612
 613
 614 static void on_confirm_button_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 615 {
 616         if(g_send_button_clicked == true){
 617                 PRINTFUNC(DLOG_DEBUG, "skipped seding STT result");
 618                 return;
 619         }
 620
 621         g_send_button_clicked = true;
 622
 623         if(!data)
 624                 return;
 625
 626         VoiceData* voicedata = (VoiceData*)data;
 627
 628         std::string result_text;
 629         for(int i = 0; i < voicedata->stt_results.size(); i++){
 630                 result_text += voicedata->stt_results.at(i);
 631                 if(i != voicedata->stt_results.size()-1)
 632                         result_text += " ";
 633         }
 634
 635         PRINTFUNC(DLOG_DEBUG, "result_text = %s", result_text.c_str());
 636         input_smartreply_send_feedback(result_text.c_str());
 637
 638         if(app_data->reply_type == REPLY_APP_CONTROL){
 639                 reply_to_sender_by_appcontrol((void*)app_data, result_text.c_str(), "voice");
 640         } else {
 641                 reply_to_sender_by_callback(result_text.c_str(), "voice");
 642                 destroy_voice();
 643                 powerUnlock();
 644                 elm_exit();
 645         }
 646
 647         return;
 648 }
 649
 650 static void
 651 _panel_cue_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 652 {
 653         PRINTFUNC(DLOG_DEBUG, "left cue clicked!!");
 654
 655         on_confirm_button_clicked_cb(data, NULL, NULL);
 656 }
 657
 658
 659
 660 void stt_feedback_initialize()
 661 {
 662         int ret = 0;
 663
 664         ret = feedback_initialize();
 665         if(ret != 0)
 666         {
 667                 PRINTFUNC(DLOG_ERROR, "feedback_initialize failed!");
 668                 return;
 669         }
 670         return;
 671 }
 672
 673 void stt_feedback(FeedbackType type)
 674 {
 675         int ret;
 676
 677         ret = feedback_initialize();
 678         if(ret != 0)
 679         {
 680                 PRINTFUNC(DLOG_ERROR, "feedback_initialize failed!");
 681                 return;
 682         }
 683
 684         if (type == VIBRATION_START){
 685 //              feedback_play(FEEDBACK_PATTERN_VOICE_START);
 686         } else if (type == VIBRATION_STOP){
 687 //              feedback_play(FEEDBACK_PATTERN_VOICE_STOP);
 688         }
 689
 690         ret = feedback_deinitialize();
 691         if(ret != 0)
 692         {
 693                 PRINTFUNC(DLOG_ERROR, "feedback_initialize failed!");
 694                 return;
 695         }
 696 }
 697
 698 void stt_feedback_deinitialize()
 699 {
 700         int ret = 0;
 701
 702         ret = feedback_deinitialize();
 703         if(ret != 0)
 704         {
 705                 PRINTFUNC(DLOG_ERROR, "feedback_initialize failed!");
 706                 return;
 707         }
 708         return;
 709 }
 710
 711 static Eina_Bool _idler_cb(void *data)
 712 {
 713         if(!data) return ECORE_CALLBACK_CANCEL;
 714
 715         VoiceData *voicedata = (VoiceData *)data;
 716
 717         PRINTFUNC(DLOG_DEBUG, "");
 718
 719
 720         if(true == _app_stt_initialize(voicedata)) {
 721                 PRINTFUNC(NO_PRINT, "_app_stt_initialize None Error");
 722                 voicedata->voicefw_state = 1;
 723                 voicedata->state = STT_STATE_VAL_INIT;
 724         } else {
 725                 voicedata->voicefw_state = 0;
 726                 PRINTFUNC(DLOG_ERROR, "Initialization Fail!<br>Check STT-daemon is running");
 727         }
 728
 729         Evas_Object *canvas = elm_object_part_content_get(voicedata->layout_main, "EFFECT_BG");
 730
 731
 732         is::ui::WInputSttMicEffect *ieffect = new is::ui::WInputSttMicEffect();
 733         ieffect->SetSttHandle(voicedata->sttmanager->GetSttHandle());
 734
 735         is::ui::MicEffector *effector = new is::ui::MicEffector(canvas, voicedata->layout_main, *ieffect);
 736         voicedata->ieffect = ieffect;
 737         voicedata->effector = effector;
 738
 739         ieffect->SetProgressBar(voicedata->progressbar);
 740         ieffect->SetSttHandle(voicedata->sttmanager->GetSttHandle());
 741
 742         voicedata->mo->Update();
 743
 744         elm_access_highlight_set(voicedata->mic_button);
 745
 746
 747         return ECORE_CALLBACK_CANCEL;
 748 }
 749
 750
 751 static Eina_Bool _power_delayed_unlock(void *data){
 752         PRINTFUNC(DLOG_DEBUG, "POWER Unlock");
 753
 754         VoiceData *voicedata = (VoiceData *) data;
 755         device_power_release_lock(POWER_LOCK_DISPLAY);
 756         voicedata->power_unlock_timer = NULL;
 757
 758         return ECORE_CALLBACK_CANCEL;
 759 }
 760
 761 void powerUnlock()
 762 {
 763         PRINTFUNC(DLOG_DEBUG, "POWER Unlock directly.");
 764         device_power_release_lock(POWER_LOCK_DISPLAY);
 765 }
 766
 767 void powerLock(void *data, bool enable)
 768 {
 769         int ret = DEVICE_ERROR_NONE;
 770
 771         VoiceData *voicedata = (VoiceData *) data;
 772
 773         if(enable) {
 774                 ret = device_power_wakeup(false);
 775                 PRINTFUNC(DLOG_DEBUG, "LCD Wakeup");
 776
 777                 if(ret != DEVICE_ERROR_NONE)
 778                         PRINTFUNC(DLOG_ERROR, "LCD Wakeup ERROR = %d", ret);
 779
 780                 ret = device_power_request_lock(POWER_LOCK_DISPLAY, 0);
 781                 PRINTFUNC(DLOG_DEBUG, "POWER LOCK");
 782                 power_state = enable;
 783
 784                 if(ret != DEVICE_ERROR_NONE)
 785                         PRINTFUNC(DLOG_ERROR, "ERROR = %d", ret);
 786
 787                 if(voicedata->power_unlock_timer != NULL){
 788                         ecore_timer_del(voicedata->power_unlock_timer);
 789                         voicedata->power_unlock_timer = NULL;
 790                 }
 791         } else {
 792                 PRINTFUNC(DLOG_DEBUG, "POWER Unlock Delayed(5 sec)");
 793
 794                 if(voicedata->power_unlock_timer != NULL){
 795                         ecore_timer_del(voicedata->power_unlock_timer);
 796                         voicedata->power_unlock_timer = NULL;
 797                 }
 798                 voicedata->power_unlock_timer = ecore_timer_add(5.0, _power_delayed_unlock, voicedata);
 799         }
 800 }
 801
 802
 803 static Eina_Bool hide_guide_text(void *data){
 804         if(data) {
 805                 VoiceData *voicedata = (VoiceData *) data;
 806
 807                 voicedata->guide_text_timer = NULL;
 808
 809
 810                 PRINTFUNC(DLOG_ERROR, "");
 811                 elm_object_part_text_set(voicedata->layout_main, "elm.text", "");
 812         }
 813         return ECORE_CALLBACK_CANCEL;
 814 }
 815
 816 static void set_guide_text(VoiceData *vd, const char* text, bool translatable)
 817 {
 818         //elm_object_signal_emit(vd->layout_main, "idle,state,text,visible", "elm");
 819
 820         if(translatable)
 821                 elm_object_domain_translatable_part_text_set(vd->layout_main, "elm.text", PACKAGE, text);
 822         else
 823                 elm_object_part_text_set(vd->layout_main, "elm.text", text);
 824
 825         if(!strcmp(text, SK_SPEAK_NOW)){
 826                 if(vd->guide_text_timer == NULL)
 827                         vd->guide_text_timer = ecore_timer_add(2.0, hide_guide_text, vd);
 828         }
 829 }
 830
 831 /**
 832  * @brief - function to send the signal to edc
 833  *               to change the animation as per stt state
 834  * @param - Ug data
 835  */
 836 void set_animation_state(VoiceData *voicedata)
 837 {
 838         PRINTFUNC(DLOG_DEBUG, "");
 839
 840         PRINTFUNC(DLOG_ERROR, "voicedata->state == %s",
 841                 voicedata->state == STT_STATE_VAL_INIT ?
 842                         "STT_STATE_VAL_INIT" :
 843                 voicedata->state == STT_STATE_VAL_LISTENING ?
 844                         "STT_STATE_VAL_LISTENING" :
 845                 voicedata->state == STT_STATE_VAL_PREPARE_LISTENING ?
 846                         "STT_STATE_VAL_PREPARE_LISTENING" :
 847                 voicedata->state == STT_STATE_VAL_PROCESSING ?
 848                         "STT_STATE_VAL_PROCESSING" :
 849                 voicedata->state == STT_STATE_VAL_PREPARE_PROCESSING ?
 850                         "STT_STATE_VAL_PREPARE_PROCESSING" :
 851                 voicedata->state == STT_STATE_VAL_TERMINATING ?
 852                         "STT_STATE_VAL_TERMINATING" : "STT_STATE_VAL_NOT_RECOGNISED");
 853
 854         if (voicedata->state == STT_STATE_VAL_INIT) {
 855 #if 0
 856                 if (voicedata->sttmanager->GetCurrent() == STT_STATE_READY) {
 857                         set_guide_text(voicedata, "", false);
 858                         //_elm_access_say(voicedata->layout_main, _(SK_INIT));
 859                 } else {
 860                         PRINTFUNC(DLOG_DEBUG, "SK_NETWORK_ERROR [%d]", voicedata->sttmanager->GetCurrent());
 861                         set_guide_text(voicedata, _(SK_NETWORK_ERROR));
 862                         //_elm_access_say(voicedata->layout_main, _(SK_NETWORK_CONNECTION_ERROR));
 863                 }
 864 #endif
 865
 866                 if(voicedata->effector)
 867                         voicedata->effector->Stop(true);
 868
 869                 set_guide_text(voicedata, "");
 870
 871                 PRINTFUNC(DLOG_DEBUG, "%d", voicedata->stt_results.size());
 872                 powerLock((void*)voicedata, false);
 873         } else if (voicedata->state == STT_STATE_VAL_LISTENING) {
 874                 set_guide_text(voicedata, SK_SPEAK_NOW, true);
 875
 876                 if(voicedata->effector)
 877                         voicedata->effector->Start();
 878
 879                 powerLock((void*)voicedata, true);
 880         } else if (voicedata->state == STT_STATE_VAL_PROCESSING) {
 881                 set_guide_text(voicedata, "");
 882                 if(voicedata->effector)
 883                         voicedata->effector->Stop();
 884
 885                 stt_feedback(VIBRATION_STOP);
 886         } else {
 887                 PRINTFUNC(DLOG_DEBUG, "SK_NETWORK_ERROR");
 888                 set_guide_text(voicedata, _(SK_RECOGNITION_FAILED));
 889                 //_elm_access_say(voicedata->layout_main, _(SK_RECOGNITION_FAILED));
 890
 891                 voicedata->state = STT_STATE_VAL_NOT_RECOGNISED;
 892
 893                 if(voicedata->refresh_timer) {
 894                         ecore_timer_del(voicedata->refresh_timer);
 895                 }
 896
 897                 if(voicedata->effector)
 898                         voicedata->effector->Stop(true);
 899
 900                 voicedata->refresh_timer = ecore_timer_add(2.0, _recognition_failure_cb, voicedata);
 901
 902                 //powerLock((void*)voicedata, false);
 903         }
 904 }
 905
 906 void show_error_message(VoiceData *vd, stt_error_e reason)
 907 {
 908         if(reason == STT_ERROR_OUT_OF_NETWORK)
 909         {
 910                 PRINTFUNC(DLOG_DEBUG, "SK_NETWORK_ERROR");
 911
 912                 int ancs_connected = 0;
 913                 int ret = 0;
 914                 ret = vconf_get_int("file/private/weconn/ancs_connected", &ancs_connected);
 915
 916                 if (ret == 0)
 917                         PRINTFUNC(DLOG_ERROR, "ancs connected status : %d", ancs_connected);
 918                 else
 919                         PRINTFUNC(DLOG_ERROR, "vconf for ancs connection ERROR - %d", ret);
 920
 921                 if (ancs_connected) {
 922                         char text[512];
 923                         snprintf(text, sizeof(text), _(SK_NETWORK_ERROR_FOR_IOS), _(SK_SAMSUNG_GEAR));
 924
 925                         show_popup_toast((const char*)text, false);
 926                 } else {
 927                         set_guide_text(vd, _(SK_NETWORK_ERROR));
 928                 }
 929
 930                 vd->state = STT_STATE_VAL_INIT;
 931
 932         } else if (reason == STT_ERROR_RECORDER_BUSY) {
 933                 PRINTFUNC(DLOG_WARN, "STT is used by another application");
 934                 show_popup_toast(_(SK_STT_BUSY), false);
 935                 vd->state = STT_STATE_VAL_INIT;
 936         } else {
 937                 PRINTFUNC(DLOG_WARN, "Check error code");
 938                 show_popup_toast(_(SK_STT_BUSY), false);
 939                 vd->state = STT_STATE_VAL_INIT;
 940         }
 941 }
 942
 943 static Eina_Bool _start_timer_cb(void* data)
 944 {
 945         if(data) {
 946                 VoiceData *voicedata = (VoiceData *) data;
 947
 948                 try {
 949                         voicedata->state = STT_STATE_VAL_PREPARE_LISTENING;
 950                         voicedata->sttmanager->Start();
 951                 }
 952                 catch (is::stt::SttException &e) {
 953                         PRINTFUNC(DLOG_ERROR, "%s", e.what());
 954
 955                         if (e.GetEcode() == STT_ERROR_OUT_OF_NETWORK)
 956                         {
 957                                 PRINTFUNC(DLOG_DEBUG, "SK_NETWORK_ERROR");
 958                                 set_guide_text(voicedata, _(SK_NETWORK_ERROR));
 959                                 voicedata->state = STT_STATE_VAL_INIT;
 960                         } else if (e.GetEcode() == STT_ERROR_RECORDER_BUSY) {
 961                                 PRINTFUNC(DLOG_WARN, "STT is used by another application");
 962                                 show_popup_toast(_(SK_STT_BUSY), false);
 963                                 voicedata->state = STT_STATE_VAL_INIT;
 964                         } else {
 965                                 PRINTFUNC(DLOG_WARN, "Check error code");
 966                                 show_popup_toast(_(SK_STT_BUSY), false);
 967                                 voicedata->state = STT_STATE_VAL_INIT;
 968                         }
 969                 }
 970                 voicedata->start_timer = NULL;
 971         }
 972         return ECORE_CALLBACK_CANCEL;
 973 }
 974
 975 /**
 976  * @brief - cancel button press callback for cross button
 977  * @param -
 978  */
 979
 980 void on_initial_anim_press_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
 981 {
 982         PRINTFUNC(NO_PRINT, "");
 983
 984         VoiceData *vd = (VoiceData *)data;
 985
 986         int tempVal = vd->sttmanager->GetCurrent();
 987         if(tempVal == STT_STATE_CREATED) {
 988                 PRINTFUNC(DLOG_WARN, "IGNORE TOUCH event before STT READY. STT is preparing", vd->state);
 989                 return;
 990         }
 991
 992         PRINTFUNC(DLOG_DEBUG, "SttManager State : %d", vd->sttmanager->GetCurrent());
 993         PRINTFUNC(DLOG_DEBUG, "Ui Voice State : %d", vd->state);
 994
 995         switch(vd->state) {
 996                 case STT_STATE_VAL_INIT:
 997
 998                         PRINTFUNC(DLOG_DEBUG, "%s", "STT_STATE_VAL_INIT");
 999                         get_stt_default_language(vd);
1000                         vd->sttmanager->SetLanguage(std::string(vd->kbd_lang));
1001
1002                         stt_feedback(VIBRATION_START);
1003
1004                         if(vd->start_timer) {
1005                                 ecore_timer_del(vd->start_timer);
1006                                 vd->start_timer = NULL;
1007                         }
1008
1009                         vd->start_timer = ecore_timer_add(0.0, _start_timer_cb, vd);
1010                         break;
1011
1012                 case STT_STATE_VAL_LISTENING :
1013                         PRINTFUNC(DLOG_DEBUG, "%s", "STT_STATE_VAL_LISTENING");
1014                         try {
1015                                 vd->state = STT_STATE_VAL_PREPARE_PROCESSING;
1016                                 vd->sttmanager->Stop();
1017
1018                                 /**
1019                                  * Cuased touch reponse time, it can be called to stop animator.
1020                                  *
1021                                  */
1022                                 set_guide_text(vd, "");
1023
1024                                 if(vd->effector)
1025                                         vd->effector->Stop();
1026                         }
1027                         catch (is::stt::SttException &e) {
1028                                 PRINTFUNC(DLOG_ERROR, "%s", e.what());
1029
1030                                 if(e.GetEcode() != STT_ERROR_INVALID_STATE) {
1031                                         PRINTFUNC(DLOG_DEBUG, "SK_NETWORK_ERROR");
1032                                         set_guide_text(vd, _(SK_RECOGNITION_FAILED));
1033                                         vd->state = STT_STATE_VAL_INIT;
1034
1035                                         if(vd->effector)
1036                                                 vd->effector->Stop(true);
1037                                 }
1038                         }
1039                         break;
1040
1041                 case STT_STATE_VAL_PROCESSING:
1042                         PRINTFUNC(DLOG_DEBUG, "%s", "STT_STATE_VAL_PROCESSING");
1043                         try {
1044                                 //vd->state = STT_STATE_VAL_PREPARE_CANCEL;
1045                                 vd->sttmanager->Cancel();
1046                         }
1047                         catch (is::stt::SttException &e) {
1048                                 PRINTFUNC(DLOG_ERROR, "%s", e.what());
1049                         }
1050
1051                         break;
1052
1053                 case STT_STATE_VAL_NOT_RECOGNISED:
1054                         PRINTFUNC(DLOG_DEBUG, "%s", "STT_STATE_VAL_NOT_RECOGNISED");
1055                         vd->state = STT_STATE_VAL_INIT ;
1056                         break;
1057                 default:
1058                         PRINTFUNC(DLOG_DEBUG, "default [%d]", vd->state);
1059                         break;
1060         }
1061 }
1062
1063 static inline void ea_naviframe_back(void *data, Evas_Object *obj, void *event_info)
1064 {
1065         if(!data) return;
1066
1067         evas_object_del((Evas_Object *) data);
1068
1069         g_setting_window = NULL;
1070         g_setting_naviframe = NULL;
1071
1072         if(g_evt_key_down)
1073                 ecore_event_handler_del(g_evt_key_down);
1074
1075         g_evt_key_down = NULL;
1076
1077         //Hide more option
1078         if(g_more_option_layout){
1079                 if(eext_more_option_opened_get(g_more_option_layout) == EINA_TRUE) {
1080                         eext_more_option_opened_set(g_more_option_layout, EINA_FALSE);
1081                 }
1082         }
1083 }
1084
1085 static char *__get_genlist_title_label(void *data, Evas_Object *obj, const char *part)
1086 {
1087         return strdup(_("WDS_VOICE_OPT_LANGUAGE_ABB"));
1088 }
1089
1090 char *__get_genlist_item_label(void *data, Evas_Object *obj, const char *part)
1091 {
1092         char text[128] = {0, };
1093
1094         if(!strcmp(part, "elm.text"))
1095         {
1096                 if((int)data == 0) {
1097                         return strdup(_("IDS_VC_BODY_AUTOMATIC"));
1098                 } else {
1099                         char *s = NULL;
1100                         if(g_is_n66) {
1101                                 s = (char *)disp_lang_array_n66[(int)data];
1102                         } else {
1103                                 s = (char *)disp_lang_array[(int)data];
1104                         }
1105
1106                         if(s) {
1107                                 char *p = strchr(s, '(');
1108                                 if(p) {
1109                                         strncpy(text, s, p-s);
1110                                 } else {
1111                                         strncpy(text, s, strlen(s));
1112                                 }
1113                         } else {
1114                                 strncpy(text, "", strlen(""));
1115                         }
1116                 }
1117                 return strdup(text);
1118         } else if (!strcmp(part, "elm.text.1")) {
1119                 if ((int)data == 0) {
1120                         char* value = NULL;
1121                         value = vconf_get_str(VCONFKEY_LANGSET);
1122                         if (NULL == value) {
1123                                 PRINTFUNC(DLOG_ERROR, "Fail to get display language");
1124                                 return NULL;
1125                         }
1126                         PRINTFUNC(DLOG_DEBUG, "system language (%s)", value);
1127
1128                         char system_lang[6] = {0, };
1129                         strncpy(system_lang, value , 5);
1130                         free(value);
1131
1132                         // confirm whether the system language is supported by stt engine or not.
1133                         // if supported, set the language
1134                         // otherwise, set language to en_US
1135                         if(g_is_n66) {
1136                                 return strdup(get_lang_label_n66(system_lang));
1137                         } else {
1138                                 return strdup(get_lang_label(system_lang));
1139                         }
1140                 } else {
1141                         char *s = NULL;
1142                         if(g_is_n66) {
1143                                 s = (char *)disp_lang_array_n66[(int)data];
1144                         } else {
1145                                 s = (char *)disp_lang_array[(int)data];
1146                         }
1147
1148                         if(s) {
1149                                 char *p = strchr(s, '(');
1150                                 if(p) {
1151                                         strncpy(text, p+1, strlen(s)-(p-s)-2);
1152                                 } else {
1153                                         strncpy(text, s, strlen(s));
1154                                 }
1155                         } else {
1156                                 strncpy(text, "", strlen(""));
1157                         }
1158                         return strdup(text);
1159                 }
1160         }
1161         return NULL;
1162 }
1163
1164 static Evas_Object *__get_genlist_item_content(void *data, Evas_Object *obj, const char *part)
1165 {
1166         int index = (int)data;
1167         Evas_Object * content = NULL;
1168
1169         if (!strcmp(part, "elm.icon")) {
1170                 content = elm_radio_add(obj);
1171                 elm_radio_state_value_set(content, index);
1172                 elm_radio_group_add(content, radio_gp);
1173                 evas_object_size_hint_weight_set(content, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1174                 evas_object_propagate_events_set(content, EINA_TRUE);
1175                 evas_object_size_hint_align_set(content, EVAS_HINT_FILL, EVAS_HINT_FILL);
1176                 elm_object_style_set(content, "list");
1177
1178                 if (elm_config_access_get())
1179                         elm_access_object_unregister(content);
1180         }
1181         return content;
1182 }
1183
1184 static int get_language_value()
1185 {
1186 #if 1
1187         int lang = 0, ret = 0;
1188
1189         ret = preference_get_int(PREFERENCE_ISE_STT_LANGUAGE, &lang);
1190         if(PREFERENCE_ERROR_NONE != ret){
1191                 PRINTFUNC(DLOG_ERROR, "preference_get_int error!(%d)", ret);
1192                 preference_set_int(PREFERENCE_ISE_STT_LANGUAGE, (int)2); //auto
1193                 lang = 2;
1194         }
1195 #else
1196         int lang = 0, ret = 0;
1197
1198         ret = vconf_get_int(VCONFKEY_ISE_STT_LANGUAGE, &lang);
1199         if (ret !=0) {
1200                 PRINTFUNC(DLOG_ERROR, "Vconf_get_int error!(%d)", ret);
1201         }
1202 #endif
1203         if(g_is_n66) {
1204                 if(lang < 0 || lang > 6) {
1205                         PRINTFUNC(DLOG_WARN, "vconf lang orig(%d) to be 0", lang);
1206                         lang = 0;
1207                 }
1208                 PRINTFUNC(DLOG_DEBUG, "n66 current language value for stt (%s).", disp_lang_array_n66[lang]);
1209         } else {
1210                 if(lang < 0 || lang > 12) {
1211                         PRINTFUNC(DLOG_WARN, "vconf lang orig(%d) to be 0", lang);
1212                         lang = 0;
1213                 }
1214                 PRINTFUNC(DLOG_DEBUG, "current language value for stt (%s).", disp_lang_array[lang]);
1215         }
1216
1217         return lang;
1218 }
1219
1220 static void set_language_value(int type)
1221 {
1222         // Add implementation to store language type.
1223         int ret = 0;
1224
1225 #if 1
1226         ret = preference_set_int(PREFERENCE_ISE_STT_LANGUAGE, (int)type);
1227         if(PREFERENCE_ERROR_NONE != ret){
1228                 PRINTFUNC(DLOG_ERROR, "preference_set_int error!(%d)", ret);
1229         }
1230
1231 #else
1232         ret = vconf_set_int(VCONFKEY_ISE_STT_LANGUAGE, (int) type);
1233         if (ret != 0) {
1234                 PRINTFUNC(DLOG_ERROR, "Vconf_set_int error!(%d)", ret);
1235                 return;
1236         }
1237 #endif
1238         PRINTFUNC(DLOG_DEBUG, "language type (%d)", type);
1239
1240         // Update string
1241 }
1242
1243 static void get_stt_default_language(VoiceData *my_voicedata)
1244 {
1245         if(!my_voicedata) {
1246                 PRINTFUNC(DLOG_ERROR, "my_voicedata NULL");
1247                 return;
1248         }
1249
1250         if(my_voicedata->kbd_lang) {
1251                 free(my_voicedata->kbd_lang);
1252                 my_voicedata->kbd_lang = NULL;
1253         }
1254
1255
1256         if(g_is_n66) {
1257                 STT_VOICE_LANGUAGE_N66_I stt_lang;
1258                 stt_lang = (STT_VOICE_LANGUAGE_N66_I)get_language_value();
1259
1260                 PRINTFUNC(DLOG_DEBUG, "language type (%d)", stt_lang);
1261
1262                 switch(stt_lang) {
1263                 case STT_VOICE_N66_AUTO :
1264                 {
1265                         stt_get_default_language(my_voicedata->voicefw_handle, &my_voicedata->kbd_lang);
1266
1267                         // get system display language
1268                         char* value = NULL;
1269                         value = vconf_get_str(VCONFKEY_LANGSET);
1270                         if (NULL == value) {
1271                                 PRINTFUNC(DLOG_ERROR, "Fail to get display language");
1272                                 return;
1273                         }
1274                         PRINTFUNC(DLOG_DEBUG, "system language (%s)", value);
1275
1276                         char system_lang[6] = {0, };
1277                         strncpy(system_lang, value , 5);
1278                         free(value);
1279
1280                         // confirm whether the system language is supported by stt engine or not.
1281                         // if supported, set the language
1282                         // otherwise, set language to en_US
1283                         if(is_lang_supported_by_stt(system_lang) == TRUE) {
1284                                 my_voicedata->kbd_lang = strdup(system_lang);
1285                                 PRINTFUNC(DLOG_DEBUG, "Set auto language (%s)", system_lang);
1286                         } else {
1287                                 my_voicedata->kbd_lang = strdup("en_US");
1288                                 PRINTFUNC(DLOG_DEBUG, "System language is not supported by STT (%s), en_US will be set", system_lang);
1289                         }
1290                 }
1291                 break;
1292                 case STT_VOICE_N66_EN_US :
1293                 case STT_VOICE_N66_ES_US :
1294                 case STT_VOICE_N66_FR_FR :
1295                 case STT_VOICE_N66_JA_JP :
1296                 case STT_VOICE_N66_KO_KR :
1297                 case STT_VOICE_N66_ZH_CN :
1298                 {
1299                         my_voicedata->kbd_lang = strdup(supported_language_n66[stt_lang]);
1300                 }
1301                 break;
1302                 default :
1303                         my_voicedata->kbd_lang = strdup("en_US");
1304                         break;
1305                 }
1306         } else {
1307                 STT_VOICE_LANGUAGE_I stt_lang;
1308                 stt_lang = (STT_VOICE_LANGUAGE_I)get_language_value();
1309
1310                 PRINTFUNC(DLOG_DEBUG, "language type (%d)", stt_lang);
1311
1312                 switch(stt_lang) {
1313                 case STT_VOICE_AUTO :
1314                 {
1315                         stt_get_default_language(my_voicedata->voicefw_handle, &my_voicedata->kbd_lang);
1316
1317                         // get system display language
1318                         char* value = NULL;
1319                         value = vconf_get_str(VCONFKEY_LANGSET);
1320                         if (NULL == value) {
1321                                 PRINTFUNC(DLOG_ERROR, "Fail to get display language");
1322                                 return;
1323                         }
1324                         PRINTFUNC(DLOG_DEBUG, "system language (%s)", value);
1325
1326                         char system_lang[6] = {0, };
1327                         strncpy(system_lang, value , 5);
1328                         free(value);
1329
1330                         // confirm whether the system language is supported by stt engine or not.
1331                         // if supported, set the language
1332                         // otherwise, set language to en_US
1333                         if(is_lang_supported_by_stt(system_lang) == TRUE) {
1334                                 my_voicedata->kbd_lang = strdup(system_lang);
1335                                 PRINTFUNC(DLOG_DEBUG, "Set auto language (%s)", system_lang);
1336                         } else {
1337                                 my_voicedata->kbd_lang = strdup("en_US");
1338                                 PRINTFUNC(DLOG_DEBUG, "System language is not supported by STT (%s), en_US will be set", system_lang);
1339                         }
1340                 }
1341                 break;
1342                 case STT_VOICE_DE_DE :
1343                 case STT_VOICE_EN_GB :
1344                 case STT_VOICE_EN_US :
1345                 case STT_VOICE_ES_ES :
1346                 case STT_VOICE_ES_US :
1347                 case STT_VOICE_FR_FR :
1348                 case STT_VOICE_IT_IT :
1349                 case STT_VOICE_JA_JP :
1350                 case STT_VOICE_KO_KR :
1351                 case STT_VOICE_RU_RU :
1352                 case STT_VOICE_ZH_CN :
1353                 case STT_VOICE_PT_BR :
1354                 {
1355                         my_voicedata->kbd_lang = strdup(supported_language[stt_lang]);
1356                 }
1357                 break;
1358                 default :
1359                         my_voicedata->kbd_lang = strdup("en_US");
1360                         break;
1361                 }
1362         }
1363
1364         PRINTFUNC(DLOG_DEBUG, "stt language (%s)", my_voicedata->kbd_lang);
1365 }
1366
1367 static Eina_Bool close_setting_window_idler_cb(void *data)
1368 {
1369         if(g_setting_window && g_setting_naviframe) {
1370                 ea_naviframe_back(g_setting_window, g_setting_naviframe, NULL);
1371         }
1372
1373         return ECORE_CALLBACK_CANCEL;
1374 }
1375
1376 static void language_set_genlist_radio_cb(void *data, Evas_Object *obj, void *event_info)
1377 {
1378         PRINTFUNC(DLOG_DEBUG, "");
1379         if(!data) return;
1380
1381         int index = 0;
1382         Evas_Object *genlist = (Evas_Object *) data;
1383
1384         Elm_Object_Item * item = (Elm_Object_Item *) event_info;
1385         if (item) {
1386                 elm_genlist_item_selected_set(item, 0);
1387                 index = (int)elm_object_item_data_get(item);
1388                 elm_genlist_item_update(item);
1389         }
1390         set_language_value(index);
1391
1392         elm_radio_value_set(radio_gp, index);
1393         ecore_timer_add(0.3, close_setting_window_idler_cb, NULL);
1394 }
1395
1396 static void language_changed_cb2(void *data, Evas_Object *obj, const char *emission, const char *source)
1397 {
1398         if(!obj) return;
1399         elm_genlist_realized_items_update(obj);
1400 }
1401
1402 Eina_Bool _ise_keydown_cb(void *data, int type, void *event)
1403 {
1404         PRINTFUNC(DLOG_DEBUG, "");
1405         if(type == ECORE_EVENT_KEY_DOWN && g_setting_window && g_setting_naviframe) {
1406                 PRINTFUNC(DLOG_DEBUG, "window will be deleted.");
1407                 ea_naviframe_back(g_setting_window, g_setting_naviframe, NULL);
1408         }
1409
1410         return ECORE_CALLBACK_DONE;
1411 }
1412
1413 char *_language_list_access_info_cb(void *data, Evas_Object *obj)
1414 {
1415         PRINTFUNC(DLOG_DEBUG, "%s", __func__);
1416
1417         int value;
1418         int index;
1419         std::string text = std::string(gettext(TTS_RADIO_BUTTON));
1420         const Elm_Object_Item *item = (Elm_Object_Item *)data;
1421
1422         Evas_Object* radio = elm_object_item_part_content_get(item, "elm.icon");
1423
1424         index = elm_genlist_item_index_get(item);
1425
1426         if(index == 1) // title
1427                 return NULL;
1428
1429
1430         value = elm_radio_value_get(radio);
1431         //PRINTFUNC(DLOG_DEBUG,"index=%d value = %d", index, value);
1432         if(index == value + 2 ){
1433                 text = text + std::string(" ") + std::string(gettext(TTS_SELECTED));
1434         } else {
1435                 text = text + std::string(" ") + std::string(gettext(TTS_NOT_SELECTED));
1436         }
1437
1438         return strdup(text.c_str());
1439 }
1440
1441 static void _language_list_item_realized(void *data, Evas_Object *obj, void *event_info) //called when list scrolled
1442 {
1443         PRINTFUNC(DLOG_DEBUG, "%s", __func__);
1444         if (elm_config_access_get()) {
1445                 Elm_Object_Item *item = (Elm_Object_Item *)event_info;
1446                 Evas_Object *item_access = elm_object_item_access_object_get(item);
1447
1448                 elm_access_info_cb_set(item_access, ELM_ACCESS_CONTEXT_INFO, _language_list_access_info_cb, (void*)item);
1449         }
1450 }
1451
1452 static Evas_Object *create_language_list(Evas_Object *parent)
1453 {
1454         if(!parent) return NULL;
1455
1456         Evas_Object *genlist = elm_genlist_add(parent);
1457         if (!genlist) return NULL;
1458
1459         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1460         elm_genlist_homogeneous_set(genlist, EINA_TRUE);
1461 //      uxt_genlist_set_bottom_margin_enabled(genlist, EINA_TRUE);
1462
1463         Evas_Object *circle_language_genlist = eext_circle_object_genlist_add(genlist, NULL);
1464         eext_circle_object_genlist_scroller_policy_set(circle_language_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
1465         evas_object_resize(circle_language_genlist, 360, 360);
1466         evas_object_show(circle_language_genlist);
1467         eext_rotary_object_event_activated_set(circle_language_genlist, EINA_TRUE);
1468
1469         int i = 0;
1470         int lang_val = 0;
1471         Elm_Object_Item * item = NULL;
1472         Elm_Object_Item * item_title = NULL;
1473
1474         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1475         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
1476
1477         radio_gp = elm_radio_add(genlist);
1478         elm_radio_state_value_set(radio_gp, -1);
1479
1480         lang_val = get_language_value();
1481
1482         //Title
1483         itc_title.item_style = "title";
1484         itc_title.func.text_get = __get_genlist_title_label;
1485         itc_title.func.content_get = NULL;
1486
1487         item_title = elm_genlist_item_append(genlist, &itc_title, (void *)-1, NULL, ELM_GENLIST_ITEM_GROUP, NULL, genlist);
1488
1489         // 2 line text
1490         itc_2text.item_style = "2text.1icon.1/sub1.multiline";
1491         itc_2text.func.text_get = __get_genlist_item_label;
1492         itc_2text.func.content_get = __get_genlist_item_content;
1493
1494
1495         item = item_append(genlist, itc_2text, (void *)0, language_set_genlist_radio_cb, genlist); // AUTO
1496
1497         if(lang_val == i) {
1498                 PRINTFUNC(DLOG_DEBUG, "%d item is choiced.", i);
1499                 elm_genlist_item_show(item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
1500         }
1501
1502         if ( item == NULL ) {
1503                 PRINTFUNC(DLOG_DEBUG, "elm_genlist_item_append was failed");
1504         }
1505
1506         // 1 line text
1507         itc_1text.item_style = "1text.1icon.1";
1508         itc_1text.func.text_get = __get_genlist_item_label;
1509         itc_1text.func.content_get = __get_genlist_item_content;
1510
1511         if(g_is_n66) {
1512                 for (i = 1; i < 7; i++)
1513                 {
1514                         char *s = (char *)disp_lang_array_n66[i];
1515
1516                         if(strchr(s, '(')){
1517                                 item = item_append(genlist, itc_2text, i, language_set_genlist_radio_cb, genlist);
1518                         } else {
1519                                 item = item_append(genlist, itc_1text, i, language_set_genlist_radio_cb, genlist);
1520                         }
1521
1522                         if(lang_val == i) {
1523                                 PRINTFUNC(DLOG_DEBUG, "%d item is choiced.", i);
1524                                 elm_genlist_item_show(item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
1525                         }
1526
1527                         if ( item == NULL ) {
1528                                 PRINTFUNC(DLOG_DEBUG, "elm_genlist_item_append was failed");
1529                                 break;
1530                         }
1531                 }
1532         } else {
1533                 for (i = 1; i < 13; i++)
1534                 {
1535                         char *s = (char *)disp_lang_array[i];
1536
1537                         if(strchr(s, '(')){
1538                                 item = item_append(genlist, itc_2text, i, language_set_genlist_radio_cb, genlist);
1539                         } else {
1540                                 item = item_append(genlist, itc_1text, i, language_set_genlist_radio_cb, genlist);
1541                         }
1542
1543                         if(lang_val == i) {
1544                                 PRINTFUNC(DLOG_DEBUG, "%d item is choiced.", i);
1545                                 elm_genlist_item_show(item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
1546                         }
1547
1548                         if ( item == NULL ) {
1549                                 PRINTFUNC(DLOG_DEBUG, "elm_genlist_item_append was failed");
1550                                 break;
1551                         }
1552                 }
1553         }
1554
1555         elm_radio_value_set(radio_gp, lang_val);
1556
1557         elm_object_signal_callback_add(genlist, "elm,system,language,change", "elm", language_changed_cb2, NULL);
1558 //      eext_rotary_event_callback_set(genlist, _language_list_rotary_cb, NULL);
1559         evas_object_smart_callback_add(genlist, "realized", _language_list_item_realized, NULL);
1560
1561
1562         g_evt_key_down = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, _ise_keydown_cb, NULL);
1563         return genlist;
1564 }
1565
1566 void create_setting_window(Evas_Object *more_option_layout)
1567 {
1568         Evas_Coord w, h;
1569
1570         Evas_Object *window = NULL;
1571         Evas_Object *layout = NULL;
1572         Evas_Object *genlist = NULL;
1573         Evas_Object *naviframe = NULL;
1574
1575         Elm_Object_Item *item = NULL;
1576
1577         const char *str = "mobile";
1578
1579         /**
1580          * Create full size window
1581          *
1582          */
1583         window = elm_win_add(NULL, "voice-input-setting", ELM_WIN_BASIC);
1584         if(!window) {
1585                 PRINTFUNC(DLOG_DEBUG, "it's fail to create window.");
1586                 return;
1587         }
1588
1589         elm_win_title_set(window, "voice-input-setting");
1590 //      ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
1591         elm_win_borderless_set(window, EINA_TRUE);
1592         evas_object_resize(window, w, h);
1593
1594         elm_win_indicator_mode_set(window, ELM_WIN_INDICATOR_HIDE);
1595         elm_win_profiles_set(window, &str, 1);
1596
1597         /**
1598          * Set window theme
1599          *
1600          */
1601 //      ea_theme_style_set(EA_THEME_STYLE_DEFAULT);
1602 //      ea_theme_changeable_ui_enabled_set(EINA_TRUE);
1603
1604         /**
1605          * Create layout for language list
1606          *
1607          */
1608         layout = elm_layout_add(window);
1609         if (layout) {
1610                 elm_layout_theme_set(layout, "layout", "application", "default");
1611                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1612                 evas_object_show(layout);
1613                 elm_win_resize_object_add(window, layout);
1614         }
1615
1616         /**
1617          * Set Window rotation
1618          *
1619          */
1620         if (elm_win_wm_rotation_supported_get(window)) {
1621                 const int rots[4] = { 0, 90, 180, 270 };
1622                 elm_win_wm_rotation_available_rotations_set(window, rots, 4);
1623         }
1624
1625         /**
1626          * Activate and show window
1627          *
1628          */
1629         elm_win_activate(window);
1630         evas_object_show(window);
1631
1632         /**
1633          * Naviframe
1634          *
1635          */
1636         naviframe = elm_naviframe_add(layout);
1637         if (naviframe == NULL){
1638                 PRINTFUNC(DLOG_DEBUG, "create navi_frame failed");
1639         }
1640
1641 //      ea_object_event_callback_add(naviframe, EA_CALLBACK_BACK, ea_naviframe_back, window);
1642         elm_object_part_content_set(layout, "elm.swallow.content", naviframe);
1643
1644         /**
1645          * Push language list
1646          *
1647          */
1648         genlist = create_language_list(naviframe);
1649
1650         //item = elm_naviframe_item_push(naviframe, "IDS_VC_HEADER_VOICE_INPUT_LANGUAGE", NULL, NULL, genlist, NULL);
1651         item = elm_naviframe_item_push(naviframe, NULL, NULL, NULL, genlist, "empty");
1652         //elm_object_item_domain_text_translatable_set(item, PACKAGE, EINA_TRUE);
1653
1654         g_setting_window = window;
1655         g_setting_naviframe = naviframe;
1656         g_more_option_layout = more_option_layout;
1657 }
1658
1659 static void language_changed_cb(void *data, Evas_Object * obj, void *event_info)
1660 {
1661         PRINTFUNC(DLOG_DEBUG, "");
1662
1663         if(!obj) return;
1664         if(!data) return;
1665 }
1666
1667 static void get_text_part_width(Evas_Object *window, const char *text, Evas_Coord *calculated_width)
1668 {
1669         if(!window) return;
1670         if(!text) return;
1671         if(!calculated_width) return;
1672
1673         Evas_Coord width, height;
1674
1675         char *strbuf = NULL;
1676         Evas_Object *tb = NULL;
1677         Evas_Textblock_Style *st = NULL;
1678         Evas_Textblock_Cursor *cur = NULL;
1679
1680         tb = evas_object_textblock_add(evas_object_evas_get(window));
1681         evas_object_textblock_legacy_newline_set(tb, EINA_FALSE);
1682
1683         st = evas_textblock_style_new();
1684         evas_textblock_style_set(st, VIRTUAL_TEXT_AREA_FONT_STYLE);
1685         evas_object_textblock_style_set(tb, st);
1686
1687         cur = evas_object_textblock_cursor_new(tb);
1688         strbuf = elm_entry_utf8_to_markup(text);
1689         evas_object_resize(tb, 360, 47);
1690
1691         evas_object_textblock_text_markup_set(tb, strbuf);
1692         evas_textblock_cursor_format_prepend(cur, "+ wrap=mixed");
1693         evas_object_textblock_size_formatted_get(tb, &width, &height);
1694         evas_object_resize(tb, width, 47);
1695
1696         *calculated_width = width;
1697
1698         if(strbuf) free(strbuf);
1699         if(tb) evas_object_del(tb);
1700         if(st) evas_textblock_style_free(st);
1701         if(cur) evas_textblock_cursor_free(cur);
1702 }
1703
1704 void _stt_lang_changed_cb(keynode_t *key, void* data)
1705 {
1706         PRINTFUNC(DLOG_DEBUG, "");
1707         if(!data) return;
1708
1709         VoiceData *vd = (VoiceData *) data;
1710         get_stt_default_language(vd);
1711         vd->sttmanager->SetLanguage(std::string(vd->kbd_lang));
1712         vd->mo->Update();
1713
1714         return;
1715 }
1716
1717 static void __done_key_cb(void *data, Evas_Object *obj, void *event_info )
1718 {
1719         PRINTFUNC(DLOG_DEBUG, "");
1720
1721         if(!obj) return;
1722         if(!data) return;
1723
1724         VoiceData *voicedata = (VoiceData *)data;
1725
1726         elm_naviframe_item_pop(voicedata->naviframe);
1727 }
1728
1729 static void __stt_detailed_entry_input_panel_event_cb(void *data, Ecore_IMF_Context *imf_context,  int value)
1730 {
1731         if(!data) return;
1732
1733         VoiceData *voicedata = (VoiceData *)data;
1734
1735         switch (value) {
1736         case ECORE_IMF_INPUT_PANEL_STATE_HIDE: // 1
1737                 elm_naviframe_item_pop(voicedata->naviframe);
1738                 break;
1739         case ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW: // 2
1740                 PRINTFUNC(DLOG_DEBUG, "keypad state will show.");
1741                 break;
1742         case ECORE_IMF_INPUT_PANEL_STATE_SHOW: // 0
1743                 PRINTFUNC(DLOG_DEBUG, "keypad state show.");
1744                 break;
1745         }
1746 }
1747
1748 static void __stt_detailed_entry_del_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1749 {
1750         if (obj) {
1751                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(obj);
1752                 ecore_imf_context_input_panel_event_callback_del(imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, __stt_detailed_entry_input_panel_event_cb);
1753                 PRINTFUNC(DLOG_DEBUG, "input_panel_event_cb is deleted.");
1754         }
1755 }
1756
1757 static Evas_Object *create_text_detiled_view(Evas_Object *parent)
1758 {
1759         string edj_path = get_resource_path();
1760         edj_path = edj_path + STT_EDJ_FILE;
1761
1762         //layout
1763         Evas_Object *layout = elm_layout_add(parent);
1764         elm_layout_file_set(layout, edj_path.c_str(), "entry_focused_layout");
1765         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1766         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1767         evas_object_show(layout);
1768
1769         //entry
1770         Evas_Object *entry = elm_entry_add(parent);
1771         evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1772         evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
1773 //      ea_entry_selection_back_event_allow_set(entry, EINA_TRUE);
1774         elm_entry_context_menu_disabled_set(entry, EINA_TRUE);
1775         elm_entry_select_allow_set(entry, EINA_FALSE);
1776 //      elm_entry_cursor_handler_disabled_set(entry, EINA_TRUE);
1777         elm_entry_single_line_set(entry, EINA_TRUE);
1778         elm_entry_scrollable_set(entry, EINA_TRUE);
1779         elm_entry_input_panel_return_key_type_set(entry, ELM_INPUT_PANEL_RETURN_KEY_TYPE_DONE);
1780
1781         evas_object_show(entry);
1782
1783         elm_object_part_content_set(layout, "contents", entry);
1784         return layout;
1785 }
1786
1787 static Eina_Bool _idler_cb2(void *data)
1788 {
1789         VoiceData *voicedata = (VoiceData *)data;
1790
1791 //      uxt_scroller_set_auto_scroll_enabled(voicedata->scroller, EINA_FALSE);
1792
1793         return ECORE_CALLBACK_CANCEL;
1794 }
1795
1796 static Eina_Bool __stt_entry_detailed_view_pop_cb(void *data, Elm_Object_Item *it)
1797 {
1798         PRINTFUNC(DLOG_DEBUG, "");
1799
1800         if(!data) return EINA_FALSE;
1801
1802         VoiceData *voicedata = (VoiceData *)data;
1803
1804         Evas_Object *main_entry = (Evas_Object *)voicedata->main_entry;
1805         Evas_Object *detailed_layout = elm_object_item_part_content_get(it, "elm.swallow.content");
1806         Evas_Object *detailed_entry = elm_object_part_content_get(detailed_layout, "contents");
1807
1808         const char *str = NULL;
1809
1810         int pos = 0;
1811         pos = elm_entry_cursor_pos_get(detailed_entry);
1812         PRINTFUNC(DLOG_DEBUG, "pos = %d", pos);
1813
1814         str =  elm_entry_entry_get(detailed_entry);
1815
1816         voicedata->stt_results.clear();
1817         voicedata->stt_results.push_back(str);
1818
1819 //      uxt_scroller_set_auto_scroll_enabled(voicedata->scroller, EINA_TRUE);
1820         elm_entry_entry_set(main_entry, str);
1821         elm_entry_cursor_pos_set(main_entry, pos);
1822
1823         int x, y, w, h;
1824         elm_entry_cursor_geometry_get(main_entry, &x, &y, &w, &h);
1825         PRINTFUNC(DLOG_DEBUG, "%d %d %d %d", x, y, w, h);
1826
1827         elm_scroller_region_bring_in(voicedata->scroller, 0, y+h, 300, 168);
1828
1829         ecore_idler_add(_idler_cb2, voicedata);
1830
1831         return EINA_TRUE;
1832 }
1833
1834 static void _stt_entry_clicked_cb(void *data, Evas_Object * obj, void *event_info)
1835 {
1836         PRINTFUNC(DLOG_DEBUG, "");
1837
1838         if(!obj) return;
1839         if(!data) return;
1840
1841         VoiceData *voicedata = (VoiceData *)data;
1842
1843         char *str = NULL;
1844
1845         int pos = 0;
1846         pos = elm_entry_cursor_pos_get(obj);
1847         PRINTFUNC(DLOG_DEBUG, "pos = %d", pos);
1848
1849         str =  elm_entry_markup_to_utf8(elm_entry_entry_get(obj));
1850
1851         if (str && strlen(str) > 0) {
1852                 try {
1853                         if (voicedata->sttmanager->GetCurrent() == STT_STATE_RECORDING ||
1854                                 voicedata->sttmanager->GetCurrent() == STT_STATE_PROCESSING) {
1855                                 voicedata->sttmanager->Cancel();
1856                                 PRINTFUNC(DLOG_DEBUG, "stt entry clicked callback during STT recording and processing");
1857                                 //return;
1858                         }
1859                 }
1860                 catch(is::stt::SttException &e) {
1861                         PRINTFUNC(DLOG_ERROR, "%s", e.what());
1862                 }
1863
1864
1865                 Evas_Object *ly_detailed_view = create_text_detiled_view(voicedata->naviframe);
1866                 // Set text
1867                 Evas_Object *detailed_entry = elm_object_part_content_get(ly_detailed_view, "contents");
1868                 elm_entry_entry_set(detailed_entry, str);
1869                 elm_entry_cursor_pos_set(detailed_entry, pos);
1870                 evas_object_smart_callback_add(detailed_entry, "activated", __done_key_cb, voicedata); // Register callback for Done key
1871
1872                 Ecore_IMF_Context *imf_context = (Ecore_IMF_Context *)elm_entry_imf_context_get(detailed_entry);
1873                 ecore_imf_context_input_panel_event_callback_add(imf_context, ECORE_IMF_INPUT_PANEL_STATE_EVENT, __stt_detailed_entry_input_panel_event_cb, voicedata);
1874                 evas_object_event_callback_add(detailed_entry, EVAS_CALLBACK_DEL, __stt_detailed_entry_del_cb, NULL);
1875
1876                 // Navi Push
1877                 Elm_Object_Item *navi_it = elm_naviframe_item_push(voicedata->naviframe, NULL, NULL, NULL, ly_detailed_view, NULL);
1878                 elm_naviframe_item_pop_cb_set(navi_it, __stt_entry_detailed_view_pop_cb, (void *)voicedata);
1879                 elm_naviframe_item_title_enabled_set(navi_it, EINA_FALSE, EINA_FALSE);
1880                 free(str);
1881         }
1882
1883         return;
1884 }
1885
1886
1887 void activate_circle_scroller_for_stt_textbox(void* data, Eina_Bool bActivate)
1888 {
1889         PRINTFUNC(DLOG_DEBUG, "");
1890
1891         if(!data) return;
1892         VoiceData *voicedata = (VoiceData *)data;
1893
1894         Evas_Object *scroller = NULL;
1895         Evas_Object *circle_scroller = NULL;
1896
1897         scroller = elm_layout_content_get((Evas_Object *)voicedata->layout_main, "text_area");
1898         circle_scroller = (Evas_Object *) evas_object_data_get(scroller, "circle");
1899         eext_rotary_object_event_activated_set(circle_scroller, bActivate);
1900 }
1901
1902 static Evas_Object *create_textblock(void* data)
1903 {
1904         if(!data) return NULL;
1905
1906         VoiceData *voicedata = (VoiceData *)data;
1907
1908         Evas_Object *scroller = NULL;
1909         Evas_Object *box = NULL;
1910         Evas_Object *inner_layout = NULL;
1911         Evas_Object *entry = NULL;
1912         Evas_Object *tb = NULL;
1913         Evas_Object *circle_scroller = NULL;
1914
1915         string edj_path = get_resource_path();
1916         edj_path = edj_path + STT_EDJ_FILE;
1917
1918         scroller = elm_scroller_add(voicedata->layout_main);
1919
1920         elm_scroller_loop_set(scroller, EINA_FALSE, EINA_FALSE);
1921
1922         evas_object_size_hint_align_set(scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
1923         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1924
1925 //      elm_scroller_page_size_set(scroller, 0, 50);
1926 //      elm_scroller_page_scroll_limit_set(scroller, 0, 1);
1927
1928         elm_object_scroll_lock_x_set(scroller, EINA_TRUE);
1929
1930 //      uxt_scroller_set_auto_scroll_enabled(scroller, EINA_FALSE);
1931
1932         circle_scroller = eext_circle_object_scroller_add(scroller, app_data->circle_surface);
1933         eext_circle_object_scroller_policy_set(circle_scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
1934         eext_rotary_object_event_activated_set(circle_scroller, EINA_TRUE);
1935
1936         box = elm_box_add(scroller);
1937
1938         inner_layout = elm_layout_add(scroller);
1939         elm_layout_file_set(inner_layout, edj_path.c_str(), "layout_textblock");
1940         evas_object_size_hint_weight_set(inner_layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1941
1942         elm_object_signal_callback_add(inner_layout, "do_scroll", "entry",
1943                 [](void *data, Evas_Object *obj, const char* signal, const char* e)
1944                 {
1945                         _bring_in_cb((void *) data);
1946                 }, (void *) scroller);
1947
1948         entry = elm_entry_add(inner_layout);
1949         voicedata->main_entry = entry;
1950         elm_entry_editable_set(entry, EINA_FALSE);
1951
1952 #define FORMAT_TEXT_AREA_FONT_STYLE \
1953         "DEFAULT='font=Tizen:style=Regular font_size=32 color=#%02x%02x%02x%02x text_class=tizen wrap=mixed align=center' newline='br' b='+ font=Tizen:style=Bold'link='+ underline=on underline_color=#%02x%02x%02x%02x'"
1954         int a, r, g, b;
1955         char customStyle[512];
1956 //      ea_theme_color_get("AT02112", &r, &g, &b, &a, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1957         snprintf(customStyle, 512, FORMAT_TEXT_AREA_FONT_STYLE, r, g, b, a, r, g, b, a);
1958
1959         elm_entry_text_style_user_push(entry, customStyle);
1960
1961         evas_object_smart_callback_add(entry, "clicked", _stt_entry_clicked_cb, voicedata);
1962
1963         elm_object_part_content_set(inner_layout, "elm.swallow.content", entry);
1964
1965         elm_box_pack_end(box, inner_layout);
1966
1967         elm_object_content_set(scroller, box);
1968         evas_object_data_set(scroller, "inner_layout", (void *) inner_layout);
1969         evas_object_data_set(scroller, "circle", (void *) circle_scroller);
1970         evas_object_show(scroller);
1971         evas_object_show(inner_layout);
1972
1973         return scroller;
1974 }
1975
1976 static Evas_Object *create_progressbar(Evas_Object *parent)
1977 {
1978         Evas_Object *progressbar = NULL;
1979
1980         progressbar = elm_progressbar_add(parent);
1981         elm_object_style_set(progressbar, "voice_input/process/small");
1982         //elm_progressbar_pulse(progressbar, EINA_TRUE);
1983
1984         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, EVAS_HINT_FILL);
1985         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1986
1987 //      ea_theme_object_color_replace(progressbar, "B065L6", "AO012");
1988
1989         evas_object_show(progressbar);
1990
1991         return progressbar;
1992 }
1993
1994 static Evas_Object *create_fullview(Evas_Object *parent, VoiceData *r_voicedata)
1995 {
1996         PRINTFUNC(NO_PRINT, "");
1997
1998         Evas_Object *more_option_layout = NULL;
1999         Evas_Object *layout_main = NULL;
2000         Evas_Object *lang_btn_box = NULL;
2001         Evas_Object *lang_btn = NULL;
2002         Evas_Object *to = NULL;
2003         Evas_Object *ao = NULL;
2004
2005         char *lang_type_str = NULL;
2006
2007         int lang_val = 0;
2008         int is_screen_reader_on = FALSE;
2009
2010         VoiceData *voicedata = r_voicedata;
2011
2012         /**
2013          * add app_default_layout
2014          *
2015          */
2016         MoreOption* mo = new MoreOption(parent, voicedata);
2017         mo->Create();
2018
2019         voicedata->mo = mo;
2020
2021
2022         layout_main = elm_layout_add(mo->getMoreOptionLayout());
2023
2024         if (!layout_main)
2025                 return NULL;
2026
2027         voicedata->layout_main = layout_main;
2028
2029         string edj_path = get_resource_path();
2030         edj_path = edj_path + STT_EDJ_FILE;
2031
2032         if (vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &is_screen_reader_on) == -1) {
2033                 PRINTFUNC(DLOG_ERROR, "Cannot read value of screen reader from vconf");
2034         }
2035
2036         evas_object_size_hint_weight_set(layout_main, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2037         evas_object_size_hint_align_set(layout_main, EVAS_HINT_FILL, EVAS_HINT_FILL);
2038
2039         elm_layout_file_set(layout_main, edj_path.c_str(), "mic_control");
2040
2041         //elm_object_content_set(parent, layout_main);
2042
2043         //Canvas for Cairo effect
2044         Evas_Object *canvas = evas_object_image_filled_add(evas_object_evas_get(layout_main));
2045 //      evas_object_image_alpha_set(canvas, EINA_TRUE);
2046         evas_object_size_hint_align_set(canvas, EVAS_HINT_FILL, EVAS_HINT_FILL);
2047         evas_object_size_hint_weight_set(canvas, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
2048         evas_object_move(canvas, 0, 0);
2049
2050         Evas_Coord CanvasW, CanvasH;
2051         CanvasW = 360;
2052         CanvasH = 74;
2053         evas_object_image_size_set(canvas, CanvasW, CanvasH);
2054         evas_object_resize(canvas, CanvasW, CanvasH);
2055         evas_object_size_hint_min_set(canvas, CanvasW, CanvasH);
2056         evas_object_show(canvas);
2057
2058         elm_object_part_content_set(layout_main, "EFFECT_BG", canvas);
2059
2060
2061         // MIC Button
2062         Evas_Object *m_mic_button = elm_button_add(layout_main);
2063         elm_object_style_set(m_mic_button, "vic/micbutton");
2064         elm_object_part_content_set(layout_main, "MIC", m_mic_button);
2065         if (elm_config_access_get()){
2066                 elm_access_info_cb_set(m_mic_button, ELM_ACCESS_INFO, _mic_access_info_cb, NULL);
2067                 elm_access_info_cb_set(m_mic_button, ELM_ACCESS_TYPE, _mic_access_info_cb, NULL);
2068                 elm_access_info_cb_set(m_mic_button, ELM_ACCESS_STATE, _mic_access_info_cb, NULL);
2069                 evas_object_smart_callback_add(m_mic_button, "access,highlighted", _mic_highlighted_cb, voicedata);
2070         }
2071
2072         elm_object_disabled_set(m_mic_button, EINA_TRUE);
2073         evas_object_smart_callback_add(m_mic_button, "clicked", on_mic_button_press_cb, (void *) voicedata);
2074
2075         voicedata->mic_button = m_mic_button;
2076
2077         if(voicedata->btn_disabling_timer == NULL){
2078                 voicedata->btn_disabling_timer = ecore_timer_add(2.0, _mic_button_enable_cb, voicedata);
2079         }
2080
2081 //      ecore_idler_add(_idler_cb, voicedata);
2082         ecore_timer_add(0.6, _idler_cb, voicedata);
2083
2084         // Confirm panel layout
2085         Evas_Object *panel_layout;
2086         panel_layout = elm_layout_add(layout_main);
2087         elm_layout_theme_set(panel_layout, "layout", "drawer", "panel");
2088         evas_object_show(panel_layout);
2089
2090         // Confirm panel
2091         Evas_Object *panel;
2092         panel = elm_panel_add(panel_layout);
2093         elm_panel_orient_set(panel, ELM_PANEL_ORIENT_LEFT);
2094         elm_layout_theme_set(panel, "panel", "left_confirm", "default");
2095         if(app_data->source_app_control){
2096                 int ret;
2097                 char *app_id = NULL;
2098                 ret = app_control_get_extra_data(app_data->source_app_control, "selector_keyboard_app_id", &app_id);
2099                 if (ret == APP_CONTROL_ERROR_NONE) {
2100                         PRINTFUNC(DLOG_DEBUG, "app_id = %s", app_id);
2101                 }
2102
2103                 if(app_id){
2104                         if(!strcmp(app_id, "com.samsung.message.appcontrol.compose")
2105                                 || !strcmp(app_id, "com.samsung.wemail-send")){
2106                                 elm_layout_theme_set(panel, "panel", "left_sending", "default");
2107                         }
2108                         free(app_id);
2109                 }
2110         }
2111
2112         elm_layout_signal_callback_add(panel, "cue,clicked", "elm", _panel_cue_clicked_cb, (void *) voicedata);
2113         evas_object_show(panel);
2114
2115         elm_object_part_content_set(panel_layout, "elm.swallow.right", panel);
2116         elm_object_part_content_set(layout_main, "left_panel_area", panel_layout);
2117
2118         elm_object_signal_emit(panel, "elm,state,disabled", "elm");
2119         elm_panel_toggle(panel);
2120
2121
2122         // Textblock
2123         Evas_Object *scroller = create_textblock(voicedata);
2124         elm_object_part_content_set(layout_main, "text_area", scroller);
2125         voicedata->scroller = scroller;
2126
2127         // Progress Bar
2128         Evas_Object *progress_bar = create_progressbar(layout_main);
2129         elm_object_part_content_set(layout_main, "PROGRESS_BAR", progress_bar);
2130         voicedata->progressbar = progress_bar;
2131
2132         // add callback
2133         elm_object_signal_callback_add(layout_main, "idle,state,pulse,visible", "", on_initial_anim_press_cb, voicedata);
2134
2135         mo->SetContentLayout(layout_main);
2136
2137         //accesbility chaining
2138         if (elm_config_access_get()) {
2139                 //right cue
2140                 Evas_Object *cue_access_right = NULL;
2141
2142                 Evas_Object *panel_right = elm_object_part_content_get(mo->getMoreOptionLayout(), "elm.swallow.right");
2143                 if (!panel_right) {
2144                     PRINTFUNC(DLOG_DEBUG, "panel_right == NULL");
2145                 }
2146                 Evas_Object *cue_right = (Evas_Object *)edje_object_part_object_get(elm_layout_edje_get(panel_right), "cue.event");
2147                 if (!cue_right) {
2148                     PRINTFUNC(DLOG_DEBUG, "cue_right == NULL");
2149                 }
2150                 Evas_Object *_access_right = elm_access_object_get(cue_right);
2151                 if (!_access_right){
2152                     PRINTFUNC(DLOG_DEBUG, "_access_right == NULL");
2153                 }
2154                 cue_access_right = _access_right;
2155
2156                 //left cue
2157                 Evas_Object *cue_access_left = NULL;
2158                 Evas_Object *panel_layout = elm_layout_content_get(layout_main, "left_panel_area");
2159                 Evas_Object *panel_left = elm_layout_content_get(panel_layout, "elm.swallow.right");
2160                 if (!panel_left) {
2161                     PRINTFUNC(DLOG_DEBUG, "panel_left == NULL");
2162                 }
2163                 Evas_Object *cue_left = (Evas_Object *)edje_object_part_object_get(elm_layout_edje_get(panel_left), "cue.event");
2164                 if (!cue_left) {
2165                     PRINTFUNC(DLOG_DEBUG, "cue_left == NULL");
2166                 }
2167                 Evas_Object *_access_left = elm_access_object_register(cue_left, panel_left);
2168                 if (!_access_left){
2169                     PRINTFUNC(DLOG_DEBUG, "_access_left == NULL");
2170                 }
2171                 elm_access_info_cb_set(_access_left, ELM_ACCESS_INFO, _left_cue_access_info_cb, panel_left);
2172                 elm_access_activate_cb_set(_access_left, _left_cue_access_activate_cb, panel_left);
2173
2174                 cue_access_left = _access_left;
2175
2176                 elm_access_highlight_next_set(m_mic_button, ELM_HIGHLIGHT_DIR_NEXT, cue_access_right);
2177                 elm_access_highlight_next_set(cue_access_right, ELM_HIGHLIGHT_DIR_PREVIOUS, m_mic_button);
2178
2179                 elm_access_highlight_next_set(cue_access_right, ELM_HIGHLIGHT_DIR_NEXT, cue_access_left);
2180                 elm_access_highlight_next_set(cue_access_left, ELM_HIGHLIGHT_DIR_PREVIOUS, cue_access_right);
2181
2182                 elm_access_highlight_next_set(cue_access_left, ELM_HIGHLIGHT_DIR_NEXT, m_mic_button);
2183                 elm_access_highlight_next_set(m_mic_button, ELM_HIGHLIGHT_DIR_PREVIOUS, cue_access_left);
2184         }
2185
2186         return layout_main;
2187 }
2188
2189 int is_lang_supported_by_stt(char lang[])
2190 {
2191         /* to check if the language is supported by stt */
2192         int index;
2193         for (index = (sizeof(supported_language) / sizeof(supported_language[0]))-1; index != 0; index--)
2194         {
2195                 if (!strcmp(lang, supported_language[index])) {
2196                         PRINTFUNC(DLOG_DEBUG, "current lang supported (%s)", supported_language[index]);
2197                         return TRUE;
2198                 }
2199         }
2200
2201         PRINTFUNC(DLOG_DEBUG, "current lang not supported (%s)", lang);
2202
2203         return FALSE;
2204 }
2205
2206 int init_voice(Evas_Object *parent, const char *lang, VoiceData *r_voicedata)
2207 {
2208         PRINTFUNC(DLOG_DEBUG, "[init_voice]");
2209
2210 //      stt_is_samsung_asr(&g_is_n66);
2211
2212         VoiceData *voicedata = (VoiceData *)r_voicedata;
2213         if (!voicedata) {
2214                 return FALSE;
2215         }
2216
2217         if (!parent) {
2218                 PRINTFUNC(DLOG_ERROR, "Parent is NULL\n");
2219                 return FALSE;
2220         } else {
2221                 PRINTFUNC(NO_PRINT, "Parent is there");
2222         }
2223
2224         voicedata->voicefw_state = 0;
2225
2226         /* Set Voice Language */
2227         if(voicedata->kbd_lang){
2228                 free(voicedata->kbd_lang);
2229                 voicedata->kbd_lang = NULL;
2230         }
2231
2232         //stt_get_default_language(my_voicedata->voicefw_handle, &my_voicedata->kbd_lang);
2233         get_stt_default_language(voicedata);
2234         if(NULL == voicedata->kbd_lang || FALSE == is_lang_supported_by_stt(voicedata->kbd_lang)) {
2235                 voicedata->kbd_lang = strdup("en_US");
2236         }
2237
2238         PRINTFUNC(DLOG_DEBUG, "Voice input active language is : %s", voicedata->kbd_lang);
2239
2240         voicedata->naviframe = parent;
2241
2242         if (NULL == voicedata->naviframe) {
2243                 return FALSE;
2244         }
2245
2246         return TRUE;
2247 }
2248
2249 static Eina_Bool init_view(void *data)
2250 {
2251         VoiceData *voicedata = (VoiceData *)data;
2252
2253         if(voicedata == NULL)
2254                 return ECORE_CALLBACK_CANCEL;
2255
2256         voicedata->layout_main = create_fullview(voicedata->naviframe, voicedata);
2257
2258         if (voicedata->layout_main) {
2259                 evas_object_show(voicedata->layout_main);
2260         }
2261
2262         return ECORE_CALLBACK_CANCEL;
2263 }
2264
2265
2266 Evas_Object *show_voice_window(Evas_Object *parent, VoiceData *r_voicedata)
2267 {
2268         PRINTFUNC(NO_PRINT, "[show_voice_window]");
2269
2270         VoiceData *voicedata = (VoiceData *)r_voicedata;
2271         if (!voicedata) {
2272                 return NULL;
2273         }
2274
2275         if (!parent) {
2276                 PRINTFUNC(NO_PRINT, "Parent is NULL\n");
2277                 return NULL;
2278         } else {
2279                 PRINTFUNC(NO_PRINT, "Parent is there");
2280         }
2281
2282         if (NULL != voicedata->layout_main) {
2283                 PRINTFUNC(DLOG_DEBUG, "delete previous layout");
2284                 evas_object_del((voicedata)->layout_main);
2285                 (voicedata)->layout_main = NULL;
2286         }
2287
2288         if (NULL != voicedata->effector) {
2289                 PRINTFUNC(DLOG_DEBUG, "delete previous effect");
2290                 delete (voicedata->effector);
2291                 (voicedata)->effector = NULL;
2292         }
2293
2294         if (NULL != voicedata->ieffect) {
2295                 PRINTFUNC(DLOG_DEBUG, "delete previous ieffect");
2296                 delete (voicedata->ieffect);
2297                 voicedata->ieffect = NULL;
2298         }
2299
2300         if(voicedata->mo) {
2301                 delete voicedata->mo;
2302                 voicedata->mo = NULL;
2303         }
2304
2305         init_view((void *)voicedata);
2306         return voicedata->layout_main;
2307 }
2308
2309
2310 void on_stt_pause(VoiceData *r_voicedata){
2311         PRINTFUNC(DLOG_DEBUG, "");
2312
2313         VoiceData *voicedata = (VoiceData *)r_voicedata;
2314
2315         if(voicedata){
2316                 try{
2317                         //voicedata->state = STT_STATE_VAL_PREPARE_CANCEL;
2318                         voicedata->sttmanager->Cancel();
2319                 }catch(is::stt::SttException &e){
2320                         PRINTFUNC(DLOG_ERROR, "reason : %s", e.what());
2321                 }
2322
2323                 //Hide more option and language settings by interrupt scenario.
2324                 close_setting_window_idler_cb(NULL);
2325                 Evas_Object *mo_layout = voicedata->mo->getMoreOptionLayout();
2326                 if(mo_layout){
2327                         if(eext_more_option_opened_get(mo_layout) == EINA_TRUE) {
2328                                 eext_more_option_opened_set(mo_layout, EINA_FALSE);
2329                         }
2330                 }
2331         }
2332 }
2333
2334 void on_destroy(VoiceData *r_voicedata)
2335 {
2336         PRINTFUNC(NO_PRINT, "");
2337
2338         VoiceData *voicedata = (VoiceData *)r_voicedata;
2339
2340         int result = STT_ERROR_NONE;
2341
2342         powerUnlock();
2343
2344         if (NULL != voicedata) {
2345                 if (NULL != voicedata->layout_main) {
2346                         voicedata->layout_main = NULL;
2347                 }
2348
2349                 if (NULL != voicedata->naviframe) {
2350                         voicedata->naviframe = NULL;
2351                 }
2352
2353                 if (NULL != voicedata->start_timer) {
2354                         ecore_timer_del(voicedata->start_timer);
2355                         voicedata->start_timer = NULL;
2356                 }
2357
2358                 if (NULL != voicedata->refresh_timer) {
2359                         ecore_timer_del(voicedata->refresh_timer);
2360                         voicedata->refresh_timer = NULL;
2361                 }
2362
2363                 if (NULL != voicedata->progressbar_timer) {
2364                         ecore_timer_del(voicedata->progressbar_timer);
2365                         voicedata->progressbar_timer = NULL;
2366                         elm_progressbar_pulse(voicedata->progressbar, EINA_FALSE);
2367                 }
2368
2369                 if (NULL != voicedata->textblock_timer) {
2370                         ecore_timer_del(voicedata->textblock_timer);
2371                         voicedata->textblock_timer = NULL;
2372                 }
2373
2374                 if (NULL != voicedata->guide_text_timer) {
2375                         ecore_timer_del(voicedata->guide_text_timer);
2376                         voicedata->guide_text_timer = NULL;
2377                 }
2378
2379                 if (NULL != voicedata->btn_disabling_timer) {
2380                         ecore_timer_del(voicedata->btn_disabling_timer);
2381                         voicedata->btn_disabling_timer = NULL;
2382                 }
2383
2384                 if (NULL != voicedata->power_unlock_timer) {
2385                         ecore_timer_del(voicedata->power_unlock_timer);
2386                         voicedata->power_unlock_timer = NULL;
2387                 }
2388
2389                 if(voicedata->kbd_lang) {
2390                         free(voicedata->kbd_lang);
2391                         voicedata->kbd_lang = NULL;
2392                 }
2393
2394                 if(voicedata->ieffect) {
2395                         delete voicedata->ieffect;
2396                         voicedata->ieffect = NULL;
2397                 }
2398
2399                 if(voicedata->effector) {
2400                         delete voicedata->effector;
2401                         voicedata->effector = NULL;
2402                 }
2403
2404                 if(voicedata->mo) {
2405                         delete voicedata->mo;
2406                         voicedata->mo = NULL;
2407                 }
2408
2409                 if(voicedata->sttmanager) {
2410                         delete voicedata->sttmanager;
2411                         voicedata->sttmanager = NULL;
2412                 }
2413
2414                 if(voicedata->sttfeedback) {
2415                         delete voicedata->sttfeedback;
2416                         voicedata->sttfeedback = NULL;
2417                 }
2418
2419                 free(voicedata);
2420         }
2421 }
2422
2423
2424