src/w-input-stt-voice.cpp

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