src/w-input-stt-voice.cpp

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