src/w-input-selector.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 "Debug.h"
  18
  19 #include <app.h>
  20 #include <dlog.h>
  21 #include <Eina.h>
  22 #include <string>
  23 #include <vconf.h>
  24 #include <vconf-keys.h>
  25 #include <stdint.h>
  26
  27 #include "w-input-selector.h"
  28 #include "w-input-template.h"
  29 #include "w-input-keyboard.h"
  30 #include "w-input-stt-ise.h"
  31 #include "w-input-emoticon.h"
  32 #include "w-input-stt-tos.h"
  33
  34 #include <stt.h>
  35
  36
  37 using namespace std;
  38
  39 App_Data* app_data = NULL;
  40
  41 InputKeyboardData g_input_keyboard_data;
  42 InputTypeData g_input_type_data;
  43
  44 static Elm_Object_Item *it_empty;
  45 static Elm_Object_Item *it_title;
  46
  47 static unsigned int g_template_item_size = 0;           /* Current Template item size */
  48
  49 Evas_Coord last_step; // 0 ~ 9 for gesture, 10~11 for rotary
  50
  51 void _init_app_data(App_Data* app_data);
  52 static void _app_language_changed(app_event_info_h event_info, void *user_data);
  53
  54 Evas_Object* _create_genlist(Evas_Object* parent);
  55 void _create_genlist_items(void* user_data);
  56 void _create_header_items(void *user_data);
  57 void _update_genlist_items(void *user_data);
  58 unsigned int _update_template_items(void *user_data);
  59 static void _popup_close_cb(void *data, Evas_Object *obj, void *event_info);
  60 static void _popup_back_cb(void *data, Evas_Object *obj, void *event_info);
  61 static void input_type_deinit(void);
  62
  63 void _init_app_data(App_Data* app_data)
  64 {
  65         app_data->win_main = NULL;
  66         app_data->layout_main = NULL;
  67         app_data->conform = NULL;
  68         app_data->naviframe = NULL;
  69         app_data->genlist = NULL;
  70
  71         app_data->res_path = NULL;
  72 }
  73
  74 Evas_Object* load_edj(Evas_Object* parent, const char* file, const char* group)
  75 {
  76         Evas_Object* window;
  77         Evas_Object* content;
  78         int ret;
  79
  80         window = elm_layout_add(parent);
  81         if (window) {
  82                 ret = elm_layout_file_set(window, file, group);
  83                 if (!ret) {
  84                         evas_object_del(window);
  85                         return NULL;
  86                 }
  87
  88                 content = elm_layout_add(parent);
  89                 elm_layout_theme_set(content, "layout", "application", "default");
  90                 elm_object_part_content_set(window, "elm.swallow.content", content);
  91
  92                 evas_object_size_hint_weight_set(window, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  93         }
  94         return window;
  95 }
  96
  97 void init_customizing_theme(void)
  98 {
  99         string stt_edj_path = get_resource_path();
 100         string app_edj_path = get_resource_path();
 101
 102         stt_edj_path = stt_edj_path + STT_EDJ_FILE;
 103         app_edj_path = app_edj_path + APP_EDJ_FILE;
 104
 105         elm_theme_extension_add(NULL, stt_edj_path.c_str());
 106         elm_theme_extension_add(NULL, app_edj_path.c_str());
 107 }
 108
 109
 110 static Eina_Bool back_cb(void *data, Elm_Object_Item *it)
 111 {
 112         reply_to_sender_by_callback_for_back();
 113         elm_exit();
 114         return EINA_FALSE;
 115 }
 116
 117 static void _stt_clicked_cb(void *data, Evas_Object * obj, void *event_info)
 118 {
 119         App_Data* ad = (App_Data*)data;
 120
 121         PRINTFUNC(DLOG_DEBUG, "");
 122
 123         if(!ad)
 124                 return;
 125
 126 #if 0
 127         bool bAgreed = false;
 128         stt_get_user_agreement(&bAgreed);
 129         if(!bAgreed){
 130 #endif
 131         if(is_tos_N66_agreed() == EINA_FALSE){
 132                 if(is_sap_connection() == EINA_TRUE){
 133                         ise_show_tos_n66_popup(ad);
 134                 } else {
 135                         launch_bt_connection_popup(ad);
 136                 }
 137         } else {
 138                 ise_show_stt_popup(ad);
 139         }
 140 }
 141
 142 static void _input_template_notify_cb(void *user_data)
 143 {
 144         _update_genlist_items((void *)app_data);
 145 }
 146
 147 static void _emoticon_clicked_cb(void *data, Evas_Object * obj, void *event_info)
 148 {
 149         App_Data* ad = (App_Data*)data;
 150
 151         PRINTFUNC(DLOG_DEBUG, "");
 152
 153         if(!ad)
 154                 return;
 155
 156         ise_show_emoticon_list(ad);
 157 }
 158
 159 static void _keyboard_clicked_cb(void *data, Evas_Object * obj, void *event_info)
 160 {
 161         App_Data* ad = (App_Data *)data;
 162
 163         PRINTFUNC(DLOG_DEBUG, "");
 164
 165         if (!ad)
 166                 return;
 167
 168         input_keyboard_launch(ad->win_main, data);
 169 }
 170
 171 static void __ise_template_gl_sel(void *data, Evas_Object *obj, void *event_info)
 172 {
 173         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 174         int index = 0;
 175
 176         if (item) {
 177                 elm_genlist_item_selected_set(item, EINA_FALSE);
 178
 179                 index = (uintptr_t) elm_object_item_data_get(item);
 180                 const std::vector<TemplateData>  template_list = input_template_get_list();
 181
 182                 if (index < (int)template_list.size()) {
 183                         reply_to_sender_by_callback(gettext(template_list[index].text.c_str()), "template");
 184                         elm_exit();
 185                 }
 186         }
 187 }
 188
 189 static char * __ise_template_gl_text_get(void *data, Evas_Object *obj, const char *part)
 190 {
 191         if(!strcmp(part, "elm.text")) {
 192                 unsigned int index = (uintptr_t)data;
 193                 const std::vector<TemplateData>  template_list = input_template_get_list();
 194
 195                 if(index < template_list.size()) {
 196                         if(template_list[index].use_gettext) {
 197                                 return strdup(gettext(template_list[index].text.c_str()));
 198                         } else {
 199                                 Eina_Strbuf *buf = NULL;
 200                                 const char *str = NULL;
 201                                 char *markup = NULL;
 202
 203                                 buf = eina_strbuf_new();
 204                                 if(buf) {
 205                                         eina_strbuf_append(buf, template_list[index].text.c_str());
 206                                         eina_strbuf_replace_all(buf, "\n", "");
 207                                         eina_strbuf_replace_all(buf, "\r", "");
 208
 209                                         str = eina_strbuf_string_get(buf);
 210
 211                                         if (str) {
 212                                                 markup = elm_entry_utf8_to_markup(str);
 213                                         }
 214                                         eina_strbuf_free(buf);
 215                                 }
 216                                 return markup;
 217                         }
 218                 }
 219         }
 220         return NULL;
 221 }
 222
 223 static Evas_Object * __ise_gl_2button_content_get(void *data, Evas_Object *obj, const char *part)
 224 {
 225         char *first_input_type = *(g_input_type_data.input_type_array + 0);
 226         char *second_input_type = *(g_input_type_data.input_type_array + 1);
 227
 228         if (!strcmp(part, "elm.icon.1") ||  (!strcmp(part, "elm.icon.2"))) {
 229                 Evas_Object* btn = elm_button_add(obj);
 230                 evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 231                 evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 232
 233                 Evas_Object* ic = elm_image_add(btn);
 234                 elm_image_resizable_set(ic, EINA_TRUE, EINA_TRUE);
 235                 string path = get_resource_path();
 236                 if (!strcmp(part, "elm.icon.1")) {
 237                         string path_ic;
 238                         if(!strcmp(first_input_type, "input_voice")) {
 239                                 elm_object_style_set(btn, "ime_button_stt");
 240                                 path_ic = path + "images/w_mode_stt_ic.png";
 241                         } else if (!strcmp(first_input_type, "input_emoticon")) {
 242                                 elm_object_style_set(btn, "ime_button_emoticon");
 243                                 path_ic = path + "images/Delta_w_mode_emoticon_ic.png";
 244                         } else if (!strcmp(first_input_type, "input_keyboard")) {
 245                                 elm_object_style_set(btn, "ime_button_keyboard");
 246                                 path_ic = path + "images/w_mode_keyboard_ic.png";
 247                                 evas_object_propagate_events_set(btn, EINA_FALSE);
 248                         }
 249                         elm_image_file_set(ic, path_ic.c_str(), NULL);
 250                         elm_object_content_set(btn, ic);
 251                         evas_object_layer_set(btn, 32000);
 252                 } else if (!strcmp(part, "elm.icon.2")){
 253                         string path_ic;
 254                         if(!strcmp(second_input_type, "input_voice")) {
 255                                 elm_object_style_set(btn, "ime_button_stt");
 256                                 path_ic = path + "images/w_mode_stt_ic.png";
 257                         } else if (!strcmp(second_input_type, "input_emoticon")) {
 258                                 elm_object_style_set(btn, "ime_button_emoticon");
 259                                 path_ic = path + "images/Delta_w_mode_emoticon_ic.png";
 260                         } else if (!strcmp(second_input_type, "input_keyboard")) {
 261                                 elm_object_style_set(btn, "ime_button_keyboard");
 262                                 path_ic = path + "images/w_mode_keyboard_ic.png";
 263                                 evas_object_propagate_events_set(btn, EINA_FALSE);
 264                         }
 265                         elm_image_file_set(ic, path_ic.c_str(), NULL);
 266                         elm_object_content_set(btn, ic);
 267                         evas_object_layer_set(btn, 32000);
 268                 }
 269                 return btn;
 270         } else if (!strcmp(part, "elm.icon.1.touch_area") ||  (!strcmp(part, "elm.icon.2.touch_area"))) {
 271                 Evas_Object* btn = elm_button_add(obj);
 272                 elm_object_style_set(btn, "touch_area");
 273                 evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 274                 evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 275                 string path = get_resource_path();
 276                 if (!strcmp(part, "elm.icon.1.touch_area")) {
 277                         evas_object_layer_set(btn, 32000);
 278                         if(!strcmp(first_input_type, "input_voice")) {
 279                                 evas_object_smart_callback_add(btn, "clicked", _stt_clicked_cb, app_data);
 280                         } else if (!strcmp(first_input_type, "input_emoticon")) {
 281                                 evas_object_smart_callback_add(btn, "clicked", _emoticon_clicked_cb, app_data);
 282                         } else if (!strcmp(first_input_type, "input_keyboard")) {
 283                                 evas_object_propagate_events_set(btn, EINA_FALSE);
 284                                 evas_object_smart_callback_add(btn, "clicked", _keyboard_clicked_cb, app_data);
 285                         }
 286                 } else if (!strcmp(part, "elm.icon.2.touch_area")){
 287                         evas_object_layer_set(btn, 32000);
 288                         if(!strcmp(second_input_type, "input_voice")) {
 289                                 evas_object_smart_callback_add(btn, "clicked", _stt_clicked_cb, app_data);
 290                         } else if (!strcmp(second_input_type, "input_emoticon")) {
 291                                 evas_object_smart_callback_add(btn, "clicked", _emoticon_clicked_cb, app_data);
 292                         } else if (!strcmp(second_input_type, "input_keyboard")) {
 293                                 evas_object_propagate_events_set(btn, EINA_FALSE);
 294                                 evas_object_smart_callback_add(btn, "clicked", _keyboard_clicked_cb, app_data);
 295                         }
 296                 }
 297                 return btn;
 298         } else if (!strcmp(part, "base")) {
 299                 Evas_Object* btn = elm_button_add(obj);
 300                 elm_object_style_set(btn, "ime_transparent");
 301                 return btn;
 302         }
 303         return NULL;
 304 }
 305
 306 static Evas_Object * __ise_gl_3button_content_get(void *data, Evas_Object *obj, const char *part)
 307 {
 308         if (!strcmp(part, "elm.icon.1") ||  (!strcmp(part, "elm.icon.2")) ||  (!strcmp(part, "elm.icon.3"))) {
 309                 Evas_Object* btn = elm_button_add(obj);
 310                 evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 311                 evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 312                 Evas_Object* ic = elm_image_add(btn);
 313                 elm_image_resizable_set(ic, EINA_TRUE, EINA_TRUE);
 314                 string path = get_resource_path();
 315                 if (!strcmp(part, "elm.icon.1")) {
 316                         elm_object_style_set(btn, "ime_button_stt");
 317                         string path_ic = path + "images/w_mode_stt_ic.png";
 318                         elm_image_file_set(ic, path_ic.c_str(), NULL);
 319                         elm_object_content_set(btn, ic);
 320                         evas_object_layer_set(btn, 32000);
 321
 322                 } else if (!strcmp(part, "elm.icon.2")){
 323                         elm_object_style_set(btn, "ime_button_emoticon");
 324                         string path_ic = path + "images/Delta_w_mode_emoticon_ic.png";
 325                         elm_image_file_set(ic, path_ic.c_str(), NULL);
 326                         elm_object_content_set(btn, ic);
 327                         evas_object_layer_set(btn, 32000);
 328
 329                 } else if (!strcmp(part, "elm.icon.3")){
 330                         elm_object_style_set(btn, "ime_button_keyboard");
 331                         string path_ic = path + "images/w_mode_keyboard_ic.png";
 332                         elm_image_file_set(ic, path_ic.c_str(), NULL);
 333                         elm_object_content_set(btn, ic);
 334                         evas_object_layer_set(btn, 32000);
 335                         evas_object_propagate_events_set(btn, EINA_FALSE);
 336                 }
 337
 338                 return btn;
 339         } else if (!strcmp(part, "elm.icon.1.touch_area") ||  (!strcmp(part, "elm.icon.2.touch_area")) ||  (!strcmp(part, "elm.icon.3.touch_area"))) {
 340                 Evas_Object* btn = elm_button_add(obj);
 341                 elm_object_style_set(btn, "touch_area");
 342                 evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 343                 evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 344                 string path = get_resource_path();
 345                 if (!strcmp(part, "elm.icon.1.touch_area")) {
 346                         evas_object_layer_set(btn, 32000);
 347                         evas_object_smart_callback_add(btn, "clicked", _stt_clicked_cb, app_data);
 348
 349                 } else if (!strcmp(part, "elm.icon.2.touch_area")){
 350                         evas_object_layer_set(btn, 32000);
 351                         evas_object_smart_callback_add(btn, "clicked", _emoticon_clicked_cb, app_data);
 352                 } else if (!strcmp(part, "elm.icon.3.touch_area")) {
 353                         evas_object_layer_set(btn, 32000);
 354                         evas_object_propagate_events_set(btn, EINA_FALSE);
 355                         evas_object_smart_callback_add(btn, "clicked", _keyboard_clicked_cb, app_data);
 356                 }
 357
 358                 return btn;
 359         } else if (!strcmp(part, "base")) {
 360                 Evas_Object* btn = elm_button_add(obj);
 361                 elm_object_style_set(btn, "ime_transparent");
 362                 return btn;
 363         }
 364         return NULL;
 365 }
 366
 367
 368 static void __ise_gl_lang_changed(void *data, Evas_Object *obj, void *event_info)
 369 {
 370         //Update genlist items. The Item texts will be translated in the _gl_text_get().
 371         elm_genlist_realized_items_update(obj);
 372 }
 373
 374 void set_source_caller_app_id(app_control_h app_control)
 375 {
 376         if(!app_control){
 377                 PRINTFUNC(DLOG_ERROR, "can't get app_control");
 378                 return;
 379         }
 380
 381         char *caller = NULL;
 382         app_control_get_caller(app_data->source_app_control, &caller);
 383
 384         if(caller){
 385                 PRINTFUNC(DLOG_DEBUG, "caller = %s", caller);
 386                 app_control_add_extra_data(app_control, "caller_appid", caller);
 387                 free(caller);
 388         }
 389 }
 390
 391 void reply_to_sender_by_callback(const char *value, const char *type)
 392 {
 393         PRINTFUNC(DLOG_DEBUG, "");
 394
 395         app_control_h app_control;
 396
 397         if(app_control_create(&app_control) == 0) {
 398                 int ret;
 399
 400                 if (value)
 401                         app_control_add_extra_data(app_control, APP_CONTROL_DATA_TEXT, value);
 402
 403                 if (type)
 404                         app_control_add_extra_data(app_control, "reply_type", type);
 405
 406                 set_source_caller_app_id(app_control);
 407
 408                 ret = app_control_reply_to_launch_request(app_control, app_data->source_app_control, APP_CONTROL_RESULT_SUCCEEDED);
 409                 if (ret != APP_CONTROL_ERROR_NONE)
 410                         PRINTFUNC(DLOG_ERROR, "reply failed : %d", ret);
 411
 412                 app_control_destroy(app_control);
 413                 app_control_destroy(app_data->source_app_control);
 414                 app_data->source_app_control = NULL;
 415         }
 416 }
 417
 418 void reply_to_sender_by_callback_for_back()
 419 {
 420         PRINTFUNC(DLOG_DEBUG, "");
 421
 422         app_control_h app_control;
 423
 424         if(app_control_create(&app_control) == 0) {
 425                 int ret;
 426
 427                 app_control_add_extra_data(app_control, "back_to_composer", "yes");
 428
 429                 ret = app_control_reply_to_launch_request(app_control, app_data->source_app_control, APP_CONTROL_RESULT_SUCCEEDED);
 430                 if (ret != APP_CONTROL_ERROR_NONE)
 431                         PRINTFUNC(DLOG_ERROR, "reply failed : %d", ret);
 432
 433                 app_control_destroy(app_control);
 434                 app_control_destroy(app_data->source_app_control);
 435                 app_data->source_app_control = NULL;
 436         }
 437 }
 438
 439 char* get_resource_path()
 440 {
 441         if(NULL == app_data->res_path) {
 442                 app_data->res_path = app_get_resource_path();
 443                 PRINTFUNC(DLOG_INFO, "set resource path = %s", app_data->res_path);
 444         }
 445         return (app_data->res_path);
 446 }
 447
 448 char* get_shared_resource_path()
 449 {
 450         if(NULL == app_data->shared_res_path) {
 451                 app_data->shared_res_path = app_get_shared_resource_path();
 452                 PRINTFUNC(DLOG_INFO, "set shared resource path = %s", app_data->shared_res_path);
 453         }
 454         return (app_data->shared_res_path);
 455 }
 456
 457 void show_gl_focus(Eina_Bool bVisible){
 458         if(app_data->genlist == NULL)
 459                 return;
 460
 461         if(bVisible == EINA_TRUE){
 462                 elm_object_signal_emit(app_data->genlist, "elm,state,focus_bg,enable", "elm");
 463                 //elm_layout_theme_set(app_data->genlist, "genlist", "base", "focus_bg");
 464                 //elm_object_signal_emit(app_data->genlist, "elm,state,focus_bg,show", "elm");
 465         } else {
 466                 elm_object_signal_emit(app_data->genlist, "elm,state,focus_bg,disable", "elm");
 467                 //elm_layout_theme_set(app_data->genlist, "genlist", "base", "default");
 468                 //elm_object_signal_emit(app_data->genlist, "elm,state,focus_bg,hide", "elm");
 469         }
 470 }
 471
 472 void show_popup_toast(const char *text, bool check_img)
 473 {
 474         PRINTFUNC(DLOG_ERROR, "show_popup_toast");
 475
 476         Evas_Object *popup;
 477
 478         popup = elm_popup_add(app_data->win_main);
 479         elm_object_style_set(popup, "toast/circle");
 480         elm_popup_orient_set(popup, ELM_POPUP_ORIENT_BOTTOM);
 481         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 482
 483         if (check_img) {
 484                 string path = get_resource_path();
 485                 string path_ic = path + "/images/toast_check_icon.png";
 486                 Evas_Object * img = elm_image_add(popup);
 487                 elm_image_file_set(img, path_ic.c_str(), NULL);
 488                 elm_object_part_content_set(popup, "toast,icon", img);
 489         }
 490         if(text) {
 491                 elm_object_part_text_set(popup, "elm.text", text);
 492         }
 493
 494         eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK, _popup_back_cb, NULL);
 495         evas_object_smart_callback_add(popup, "dismissed", _popup_close_cb, NULL);
 496         evas_object_smart_callback_add(popup, "block,clicked", _popup_back_cb, NULL);
 497
 498         elm_popup_timeout_set(popup, 2.0);
 499         evas_object_show(popup);
 500 }
 501
 502 static void _popup_close_cb(void *data, Evas_Object *obj, void *event_info)
 503 {
 504         if(obj){
 505                 evas_object_hide(obj);
 506                 evas_object_del(obj);
 507         }
 508 }
 509
 510 static void _popup_back_cb(void *data, Evas_Object *obj, void *event_info)
 511 {
 512         if(obj)
 513                 elm_popup_dismiss(obj);
 514 }
 515
 516
 517 void _back_to_genlist_for_selector()
 518 {
 519         PRINTFUNC(DLOG_DEBUG, "");
 520
 521         if(!app_data) return;
 522
 523         if(app_data->app_type == APP_TYPE_STT || app_data->app_type == APP_TYPE_EMOTICON){
 524                 PRINTFUNC(DLOG_DEBUG, "launched as STT/EMOTICON mode, So exit here.");
 525                 reply_to_sender_by_callback(NULL, NULL);
 526                 elm_exit();
 527         }
 528
 529         Evas_Object *circle_genlist = (Evas_Object *) evas_object_data_get(app_data->genlist, "circle");
 530
 531         eext_rotary_object_event_activated_set(circle_genlist, EINA_TRUE);
 532 }
 533
 534 static void _item_realized(void *data, Evas_Object *obj, void *event_info) //called when list scrolled
 535 {
 536         PRINTFUNC(DLOG_DEBUG, "%s", __func__);
 537 }
 538
 539 Evas_Object* _create_genlist(Evas_Object* navi)
 540 {
 541         Evas_Object* genlist = elm_genlist_add(navi);
 542         if(NULL == genlist)
 543                 return NULL;
 544
 545         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 546
 547         Evas_Object* circle_object_genlist = eext_circle_object_genlist_add(genlist, app_data->circle_surface);
 548         eext_circle_object_genlist_scroller_policy_set(circle_object_genlist, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
 549         evas_object_data_set(genlist, "circle", (void *) circle_object_genlist);
 550         eext_rotary_object_event_activated_set(circle_object_genlist, EINA_TRUE);
 551
 552         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 553         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 554
 555         evas_object_smart_callback_add(genlist, "language,changed", __ise_gl_lang_changed, genlist);
 556         evas_object_show(genlist);
 557
 558 //      uxt_genlist_set_bottom_margin_enabled(genlist, EINA_TRUE);
 559
 560         show_gl_focus(EINA_FALSE);
 561
 562         Elm_Object_Item *nf_main_item = elm_naviframe_item_push(navi,
 563             NULL,
 564             NULL,
 565             NULL,
 566             genlist,
 567             "empty");
 568
 569         elm_naviframe_item_pop_cb_set(nf_main_item, back_cb, app_data);
 570         evas_object_smart_callback_add(genlist, "realized", _item_realized, NULL);
 571
 572         return genlist;
 573 }
 574
 575 static void _item_position_changed_cb(void *data, Evas_Object *obj, void *event_info)
 576 {
 577         if(!obj) return;
 578         if(!data) return;
 579
 580         Evas_Object *genlist = (Evas_Object *)obj;
 581         Elm_Object_Item *gen_item = (Elm_Object_Item *)data;
 582
 583         Evas_Coord y;
 584         elm_scroller_region_get(genlist, NULL, &y, NULL, NULL);
 585
 586 //      PRINTFUNC(DLOG_DEBUG,"y=%d",y);
 587
 588         if (250 > y && y >= 100){
 589                 if (last_step == 0) return;
 590                 last_step = 0;
 591                 elm_object_item_signal_emit(gen_item, "elm,action,ime,0.0", "elm");
 592                 show_gl_focus(EINA_TRUE);
 593         } else if (100 > y && y >= 50){
 594                 if (last_step == 1) return;
 595                 last_step = 1;
 596                 elm_object_item_signal_emit(gen_item, "elm,action,ime,0.1", "elm");
 597                 show_gl_focus(EINA_TRUE);
 598         } else if (y < 50 && y >=0){
 599                 if (last_step == 2) return;
 600                 last_step = 2;
 601                 elm_object_item_signal_emit(gen_item, "elm,action,ime,0.9", "elm");
 602                 show_gl_focus(EINA_FALSE);
 603         }
 604 }
 605
 606 static char *
 607 _main_menu_title_text_get(void *data, Evas_Object *obj, const char *part)
 608 {
 609         char buf[1024];
 610
 611         snprintf(buf, 1023, "%s", "Select method");
 612         return strdup(buf);
 613 }
 614
 615 void _create_genlist_items(void* user_data)
 616 {
 617         App_Data* app_data = (App_Data*) user_data;
 618
 619         if(NULL == app_data->genlist) {
 620                 app_data->genlist = _create_genlist(app_data->naviframe);
 621                 if(NULL == app_data->genlist)
 622                 return;
 623         }
 624
 625         elm_genlist_clear(app_data->genlist);
 626
 627         Elm_Genlist_Item_Class * itc0 = elm_genlist_item_class_new();
 628         itc0->item_style = "title";
 629         itc0->func.text_get = _main_menu_title_text_get;
 630         itc0->func.content_get = NULL;
 631         itc0->func.state_get = NULL;
 632         itc0->func.del = NULL;
 633
 634         Elm_Genlist_Item_Class * itc1 = elm_genlist_item_class_new();
 635         if(g_input_type_data.input_type_array_len == 2){
 636                 itc1->item_style = "2button_flat";
 637                 itc1->func.text_get = NULL;
 638                 itc1->func.content_get = __ise_gl_2button_content_get;
 639                 itc1->func.state_get = NULL;
 640                 itc1->func.del = NULL;
 641         } else {
 642                 itc1->item_style = "3button_flat";
 643                 itc1->func.text_get = NULL;
 644                 itc1->func.content_get = __ise_gl_3button_content_get;
 645                 itc1->func.state_get = NULL;
 646                 itc1->func.del = NULL;
 647         }
 648
 649         // dummy title for empty space
 650         it_empty = elm_genlist_item_append(app_data->genlist, itc0,
 651                         NULL, NULL,
 652                         ELM_GENLIST_ITEM_NONE,
 653                         NULL, NULL);
 654
 655         // 3 Buttons
 656         it_title = elm_genlist_item_append(app_data->genlist, itc1,
 657                         NULL, NULL,
 658                         ELM_GENLIST_ITEM_NONE,
 659                         NULL, NULL);
 660
 661         elm_genlist_item_select_mode_set(it_title, ELM_OBJECT_SELECT_MODE_NONE);
 662
 663         g_template_item_size = _update_template_items(app_data);
 664
 665         Elm_Object_Item *item = elm_genlist_item_next_get(it_title);
 666         elm_genlist_item_show(item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
 667
 668         evas_object_smart_callback_add(app_data->genlist, "elm,item,position,changed", _item_position_changed_cb, it_title);
 669
 670         elm_genlist_item_class_free(itc0);
 671         elm_genlist_item_class_free(itc1);
 672 }
 673
 674 void _create_header_items(void *user_data)
 675 {
 676         Elm_Genlist_Item_Class * itc0 = elm_genlist_item_class_new();
 677         itc0->item_style = "title";
 678         itc0->func.text_get = NULL;
 679         itc0->func.content_get = NULL;
 680         itc0->func.state_get = NULL;
 681         itc0->func.del = NULL;
 682
 683         Elm_Genlist_Item_Class * itc1 = elm_genlist_item_class_new();
 684         if (g_input_type_data.input_type_array_len == 2) {
 685                 itc1->item_style = "2button_flat";
 686                 itc1->func.text_get = NULL;
 687                 itc1->func.content_get = __ise_gl_2button_content_get;
 688                 itc1->func.state_get = NULL;
 689                 itc1->func.del = NULL;
 690         } else {
 691                 itc1->item_style = "3button_flat";
 692                 itc1->func.text_get = NULL;
 693                 itc1->func.content_get = __ise_gl_3button_content_get;
 694                 itc1->func.state_get = NULL;
 695                 itc1->func.del = NULL;
 696         }
 697
 698         // dummy title for empty space
 699         it_empty = elm_genlist_item_append(app_data->genlist, itc0,
 700                                 NULL, NULL,
 701                                 ELM_GENLIST_ITEM_NONE,
 702                                 NULL, NULL);
 703
 704         // 3 Buttons
 705         it_title = elm_genlist_item_append(app_data->genlist, itc1,
 706                                                         NULL, NULL,
 707                                                         ELM_GENLIST_ITEM_NONE,
 708                                                         NULL, NULL);
 709
 710         elm_genlist_item_select_mode_set(it_title, ELM_OBJECT_SELECT_MODE_NONE);
 711
 712         elm_genlist_item_class_free(itc0);
 713         elm_genlist_item_class_free(itc1);
 714 }
 715
 716 void _update_genlist_items(void *user_data)
 717 {
 718         elm_genlist_clear(app_data->genlist);
 719
 720         _create_header_items(user_data);
 721
 722         g_template_item_size = _update_template_items(user_data);
 723
 724         /* Update genlist item position */
 725         Elm_Object_Item *item = elm_genlist_item_next_get(it_title);
 726         elm_genlist_item_show(item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
 727 }
 728
 729 unsigned int _update_template_items(void *user_data)
 730 {
 731         App_Data* app_data;
 732
 733         Elm_Object_Item *first;
 734
 735         unsigned int i = 0;
 736         unsigned int item_size = 0;
 737
 738         app_data = (App_Data *)user_data;
 739
 740         if (app_data == NULL) {
 741                 PRINTFUNC(DLOG_ERROR, "Can not get app_data");
 742                 return item_size;
 743         }
 744
 745         if (app_data->genlist == NULL) {
 746                 /* smartreply will update when genlist is exist only */
 747                 PRINTFUNC(DLOG_ERROR, "Can not get getlist");
 748                 return item_size;
 749         }
 750
 751         first = elm_genlist_first_item_get(app_data->genlist);
 752         if (first == NULL)
 753                 return 0;
 754         elm_genlist_item_next_get(first);
 755
 756         /* Append New Template list */
 757         const std::vector<TemplateData> template_list = input_template_get_list();
 758
 759         if (template_list.size() > 0) {
 760                 Elm_Genlist_Item_Class *itc;
 761
 762                 itc = elm_genlist_item_class_new();
 763
 764                 itc->item_style = "1text";
 765                 itc->func.text_get = __ise_template_gl_text_get;
 766                 itc->func.content_get = NULL;
 767                 itc->func.state_get = NULL;
 768                 itc->func.del = NULL;
 769
 770                 for (i = 0; i < template_list.size(); i++) {
 771                         elm_genlist_item_append(app_data->genlist,
 772                                         itc,
 773                                         (void *)(uintptr_t)i,
 774                                         NULL,
 775                                         ELM_GENLIST_ITEM_NONE,
 776                                         __ise_template_gl_sel,
 777                                         app_data);
 778                         item_size++;
 779                 }
 780                 elm_genlist_item_class_free(itc);
 781         }
 782
 783         return item_size;
 784 }
 785
 786 bool _app_create(void* user_data)
 787 {
 788         int width = 1000, height = 1000;
 789 //      App_Data* app_data = NULL;
 790         Evas_Object* layout = NULL;
 791         Evas_Object* conform = NULL;
 792         Evas_Object* bg = NULL;
 793         Evas_Object* window = NULL;
 794         Eext_Circle_Surface *surface;
 795
 796         if (!user_data) {
 797                 return false;
 798         }
 799
 800         _app_language_changed(NULL, NULL);
 801
 802         app_data = (App_Data*)user_data;
 803
 804         elm_app_base_scale_set(1.3);
 805
 806         window = elm_win_add(NULL, PACKAGE, ELM_WIN_BASIC);
 807         if (window) {
 808                 init_customizing_theme();
 809
 810                 elm_win_title_set(window, PACKAGE);
 811                 elm_win_borderless_set(window, EINA_TRUE);
 812 //              ecore_x_window_size_get(ecore_x_window_root_first_get(), &width, &height);
 813                 evas_object_resize(window, width, height);
 814                 elm_win_indicator_mode_set(window, ELM_WIN_INDICATOR_SHOW);
 815         } else {
 816                 LOGE("elm_win_add() is failed.");
 817                 return false;
 818         }
 819
 820         bg = elm_bg_add(window);
 821         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 822         elm_win_resize_object_add(window, bg);
 823         evas_object_show(bg);
 824
 825         layout = elm_layout_add(window);
 826         elm_layout_theme_set(layout, "layout", "application", "default");
 827         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 828
 829         conform = elm_conformant_add(window);
 830         surface = eext_circle_surface_conformant_add(conform);
 831         evas_object_size_hint_weight_set(conform, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 832
 833
 834         elm_win_resize_object_add(window, conform);
 835         elm_object_content_set(conform, layout);
 836
 837         evas_object_show(layout);
 838         evas_object_show(conform);
 839         evas_object_show(window);
 840         app_data->win_main = window;
 841         app_data->conform = conform;
 842         app_data->layout_main = layout;
 843         app_data->circle_surface = surface;
 844         app_data->app_type = APP_TYPE_SELECT_MODE;
 845
 846         Evas_Object *naviframe = elm_naviframe_add(layout);
 847         elm_naviframe_prev_btn_auto_pushed_set(naviframe, EINA_FALSE);
 848         eext_object_event_callback_add(naviframe, EEXT_CALLBACK_BACK, eext_naviframe_back_cb, NULL);
 849         elm_object_part_content_set(layout, "elm.swallow.content", naviframe);
 850         evas_object_show(naviframe);
 851
 852         app_data->naviframe = naviframe;
 853
 854         return true;
 855 }
 856
 857 void _app_service(app_control_h service, void* user_data)
 858 {
 859         int ret;
 860         char *context = NULL;
 861         char **input_type_array = NULL;
 862         int input_type_array_len = -1;
 863         bool is_extra_data_array = false;
 864
 865         app_control_clone(&(app_data->source_app_control), service);
 866         app_data->reply_type = REPLY_APP_NORMAL;
 867
 868         ret = app_control_is_extra_data_array(service, APP_CONTROL_DATA_INPUT_TYPE, &is_extra_data_array);
 869         if( is_extra_data_array == true) {
 870                 ret = app_control_get_extra_data_array(service, APP_CONTROL_DATA_INPUT_TYPE, &input_type_array, &input_type_array_len);
 871                 g_input_type_data.input_type_array = input_type_array;
 872                 g_input_type_data.input_type_array_len = input_type_array_len;
 873         } else {
 874                 ret = app_control_get_extra_data(service, APP_CONTROL_DATA_INPUT_TYPE, &context);
 875                 if (ret == APP_CONTROL_ERROR_NONE) {
 876                         if (!strcmp(context, "input_voice")) {
 877                                 app_data->app_type = APP_TYPE_STT;
 878                                 _stt_clicked_cb((void *)app_data, NULL, NULL);
 879                                 goto ACTIVATE;
 880                         } else if (!strcmp(context, "input_emoticon")) {
 881                                 app_data->app_type = APP_TYPE_EMOTICON;
 882                                 _emoticon_clicked_cb((void *)app_data, NULL, NULL);
 883                                 goto ACTIVATE;
 884                         } else if (!strcmp(context, "input_keyboard")) {
 885                                 app_data->app_type = APP_TYPE_KEYBOARD;
 886                                 input_keyboard_init(service);
 887                                 _keyboard_clicked_cb((void *)app_data, NULL, NULL);
 888                                 goto ACTIVATE;
 889                         } else if (!strcmp(context, "input_reply")) {
 890                                 app_data->app_type = APP_TYPE_REPLY;
 891                         }
 892                 }
 893         }
 894
 895         if (app_data->genlist == NULL)
 896                 app_data->genlist = _create_genlist(app_data->naviframe);
 897
 898         input_keyboard_init(service);
 899
 900         input_template_init(service);
 901         input_template_set_notify(_input_template_notify_cb,  NULL);
 902
 903         _create_genlist_items(app_data);
 904
 905 ACTIVATE :
 906         elm_win_activate(app_data->win_main);
 907
 908         if(context)
 909                 free(context);
 910 }
 911
 912
 913 void _app_pause(void* user_data)
 914 {
 915         PRINTFUNC(DLOG_DEBUG, "");
 916         pause_voice();
 917 }
 918
 919 void _app_resume(void* user_data)
 920 {
 921         PRINTFUNC(DLOG_DEBUG, "");
 922 }
 923
 924 void _app_terminate(void* user_data)
 925 {
 926         App_Data* app_data = NULL;
 927         app_data = (App_Data*)user_data;
 928
 929         if(app_data->genlist){
 930                 evas_object_smart_callback_del(app_data->genlist, "elm,item,position,changed", _item_position_changed_cb);
 931         }
 932
 933         if(app_data->res_path)
 934                 free(app_data->res_path);
 935
 936         if(app_data->shared_res_path)
 937                 free(app_data->shared_res_path);
 938
 939         input_keyboard_deinit();
 940
 941         input_template_unset_notify();
 942         input_template_deinit();
 943
 944         input_type_deinit();
 945 }
 946
 947 static int init_i18n(const char *domain, const char *dir, char *lang_str)
 948 {
 949         if (setlocale(LC_ALL, "") == NULL) {
 950                 PRINTFUNC(DLOG_INFO, "Some environment variable is invalid, setlocale(LC_ALL, \"\") has returns\ed a null pointer");
 951                 if (setlocale(LC_ALL, lang_str) == NULL)
 952                         return -1;
 953         }
 954         if (bindtextdomain(domain, dir) == NULL)
 955                 return -1;
 956         if (textdomain(domain) == NULL)
 957                 return -1;
 958
 959         return 0;
 960 }
 961
 962 /**
 963  * @brief Set language and locale.
 964  *
 965  * @return void
 966  */
 967 static void _app_language_changed(app_event_info_h event_info, void *user_data)
 968 {
 969         char* lang_str = vconf_get_str(VCONFKEY_LANGSET);
 970         if (lang_str) {
 971                 setenv("LANG", lang_str, 1);
 972                 setenv("LC_MESSAGES", lang_str, 1);
 973         } else {
 974                 setenv("LANG", "en_GB.utf8", 1);
 975                 setenv("LC_MESSAGES", "en_GB.utf8", 1);
 976                 lang_str = strdup("en_GB.UTF-8");
 977         }
 978
 979         init_i18n(PACKAGE, LOCALEDIR, lang_str);
 980
 981         if (lang_str) {
 982                 elm_language_set(lang_str);
 983                 free(lang_str);
 984         }
 985 }
 986
 987 void input_type_deinit(void)
 988 {
 989         int i = 0;
 990         char **data_array = NULL;
 991
 992         data_array = g_input_type_data.input_type_array;
 993         if (data_array) {
 994                 for (i = 0; i < g_input_type_data.input_type_array_len; i++) {
 995                         if (*(data_array + i))
 996                                 free(*(data_array + i));
 997                 }
 998                 free(data_array);
 999         }
1000         g_input_type_data.input_type_array = NULL;
1001         g_input_type_data.input_type_array_len = 0;
1002 }
1003
1004 EXPORTED int main(int argc, char* argv[])
1005 {
1006         App_Data app_data = {0, };
1007         ui_app_lifecycle_callback_s event_callback = {0, };
1008         app_event_handler_h handlers[5] = {NULL, };
1009
1010         event_callback.create = _app_create;
1011         event_callback.terminate = _app_terminate;
1012         event_callback.pause = _app_pause;
1013         event_callback.resume = _app_resume;
1014         event_callback.app_control = _app_service;
1015
1016         ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, NULL, &app_data);
1017         ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, NULL, &app_data);
1018         ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, NULL, &app_data);
1019         ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, _app_language_changed, &app_data);
1020         ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, NULL, &app_data);
1021
1022         _init_app_data(&app_data);
1023
1024         int ret = ui_app_main(argc, argv, &event_callback, &app_data);
1025         if (ret != APP_ERROR_NONE) {
1026                 LOGD("ui_app_main() is failed. err = %d", ret);
1027         }
1028
1029         return ret;
1030 }