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