src/smartsearch.cpp

   1 /*
   2  * Copyright 2012-2013 Samsung Electronics Co., Ltd/
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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
  18
  19
  20
  21
  22 #include <stdio.h>
  23 #include <utilX.h>
  24 #include <ui-gadget.h>
  25
  26 #include "smartsearch.h"
  27 #include "search_bar.h"
  28 #include "ps_makeupviews.h"
  29 #include "ps_searcher.h"
  30
  31 #include <app.h>
  32 #include <app_manager.h>
  33
  34 struct search_content_object_default {
  35         int order;
  36         int visible;
  37         char name[DEF_BUF_LEN];
  38         int string_type;
  39         int contents_type;
  40         int category_type;
  41         char def_pkg_name[DEF_BUF_LEN];
  42 };
  43
  44 struct search_category_info_default {
  45         char btn_icon_path[MAX_LENGTH_PER_PATH];
  46         char btn_icon_press_path[MAX_LENGTH_PER_PATH];
  47 };
  48
  49 static struct search_content_object_default def_obj[SEARCH_CONT_MAX] = {
  50         { 0,  EINA_TRUE, "IDS_COM_BODY_CONTACTS", SEARCH_STR_TYPE_SYSTEM_STRING,
  51                 SEARCH_CONT_PHONE_CONTACTS, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.contacts" },
  52         { 1,  EINA_TRUE, "IDS_COM_BODY_MESSAGES", SEARCH_STR_TYPE_SYSTEM_STRING,
  53                 SEARCH_CONT_PHONE_MSG, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.message" },
  54         { 2,  EINA_TRUE, "IDS_COM_BODY_EMAIL", SEARCH_STR_TYPE_SYSTEM_STRING,
  55                 SEARCH_CONT_PHONE_EMAIL, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.email" },
  56         { 3,  EINA_TRUE, "IDS_COM_BODY_IMAGES", SEARCH_STR_TYPE_SYSTEM_STRING,
  57                 SEARCH_CONT_PHONE_IMAGES, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.image-viewer"},
  58         { 4,  EINA_TRUE, "IDS_COM_BODY_MUSIC", SEARCH_STR_TYPE_SYSTEM_STRING,
  59                 SEARCH_CONT_PHONE_MUSIC, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.music-player"},
  60         { 5,  EINA_TRUE, "IDS_COM_BODY_VIDEOS", SEARCH_STR_TYPE_SYSTEM_STRING,
  61                 SEARCH_CONT_PHONE_VIDEO, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.video-player"},
  62         { 6,  EINA_TRUE, "IDS_COM_BODY_CALENDAR", SEARCH_STR_TYPE_SYSTEM_STRING,
  63                 SEARCH_CONT_PHONE_CALENDAR, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.calendar"},
  64         { 7,  EINA_TRUE, "IDS_COM_BODY_MEMO", SEARCH_STR_TYPE_SYSTEM_STRING,
  65                 SEARCH_CONT_PHONE_MEMO, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.memo"},
  66         { 8,  EINA_TRUE, "IDS_COM_BODY_APPLICATIONS", SEARCH_STR_TYPE_SYSTEM_STRING,
  67                 SEARCH_CONT_PHONE_MENU, SEARCH_OBJ_PHONE_CONTENTS, {0} },
  68         { 9,  EINA_TRUE, "IDS_COM_BODY_INTERNET", SEARCH_STR_TYPE_SYSTEM_STRING,
  69                 SEARCH_CONT_PHONE_BROWSER, SEARCH_OBJ_PHONE_CONTENTS, "org.tizen.browser"},
  70 };
  71
  72 static struct search_category_info_default def_category[SEARCH_CATE_MAX] = {
  73         { "B10_btn_icon_Phone.png", "B10_btn_icon_Phone_press.png" },
  74 };
  75
  76 static void __search_win_delete_cb(void *data, Evas_Object * obj,
  77                                    void *event_info)
  78 {
  79         SEARCH_FUNC_START;
  80
  81         elm_exit();
  82
  83         SEARCH_FUNC_END;
  84 }
  85
  86 static Eina_Bool __search_mousedown_event(void *data, int type, void *event)
  87 {
  88         SEARCH_FUNC_START;
  89
  90         struct appdata *ad = (struct appdata *)data;
  91         Ecore_Event_Mouse_Button *ev = NULL;
  92         SEARCH_RETV_IF(ad == NULL, ECORE_CALLBACK_CANCEL);
  93         SEARCH_RETV_IF(event == NULL, ECORE_CALLBACK_CANCEL);
  94
  95         ev = (Ecore_Event_Mouse_Button *) event;
  96
  97         SEARCH_RETV_IF(ev == NULL, ECORE_CALLBACK_CANCEL);
  98
  99         ad->touch_x = ev->x;
 100         ad->touch_y = ev->y;
 101         return ECORE_CALLBACK_CANCEL;
 102 }
 103
 104
 105 static Eina_Bool __search_keydown_event(void *data, int type, void *event)
 106 {
 107         SEARCH_FUNC_START;
 108
 109         Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
 110         SEARCH_RETV_IF(ev == NULL, EINA_FALSE);
 111
 112         if (!SEARCH_STRCMP(ev->keyname, KEY_END)) {
 113                 //end key concept is close.
 114                 elm_exit();
 115         }
 116
 117         SEARCH_FUNC_END;
 118
 119         return EINA_FALSE;
 120 }
 121
 122 static void __search_delete_layout_main(void *data)
 123 {
 124         SEARCH_FUNC_START;
 125         SEARCH_RET_IF(data == NULL);
 126
 127         struct appdata *ad = (struct appdata *)data;
 128
 129         SEARCH_EVAS_OBJECT_FREE(ad->layout_main);
 130         SEARCH_EVAS_OBJECT_FREE(ad->navi_bar);
 131         SEARCH_EVAS_OBJECT_FREE(ad->back_btn);
 132
 133         search_delete_searchbar_layout(ad);
 134         SEARCH_FUNC_END;
 135 }
 136
 137 static Evas_Object *__search_create_bg(Evas_Object * parent) {
 138         SEARCH_FUNC_START;
 139
 140         Evas_Object *bg = NULL;
 141         SEARCH_RETV_IF(parent == NULL, NULL);
 142
 143         bg = elm_bg_add(parent);
 144         SEARCH_RETV_IF(bg == NULL, NULL);
 145
 146         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 147         elm_win_resize_object_add(parent, bg);
 148         evas_object_show(bg);
 149
 150         SEARCH_FUNC_END;
 151         return bg;
 152 }
 153
 154 static Evas_Object *__search_create_conformant(Evas_Object * parent) {
 155         SEARCH_FUNC_START;
 156
 157         Evas_Object *conformant = NULL;
 158         SEARCH_RETV_IF(parent == NULL, NULL);
 159
 160         conformant = elm_conformant_add(parent);
 161
 162         SEARCH_RETV_IF(conformant == NULL, NULL);
 163
 164         evas_object_size_hint_weight_set(conformant, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 165         elm_win_resize_object_add(parent, conformant);
 166         evas_object_show(conformant);
 167
 168         SEARCH_FUNC_END;
 169
 170         return conformant;
 171 }
 172
 173 static Evas_Object *__search_create_layout_main(Evas_Object *parent, Evas_Object *bg)
 174 {
 175         SEARCH_FUNC_START;
 176         Evas_Object *layout = NULL;
 177
 178         SEARCH_RETV_IF(parent == NULL, NULL);
 179
 180         layout = elm_layout_add(parent);
 181
 182         SEARCH_RETV_IF(layout == NULL, NULL);
 183
 184         //elm_layout_theme_set(layout, "standard", "window", "integration");
 185         elm_layout_theme_set(layout, "layout", "application", "default");
 186
 187         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 188         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 189         elm_object_part_content_set(layout, "elm.swallow.bg", bg);
 190
 191         edje_object_signal_emit(_EDJ(layout), "elm,state,show,indicator","elm");
 192         edje_object_signal_emit(_EDJ(layout), "elm,state,show,content", "elm");
 193         evas_object_show(layout);
 194
 195         SEARCH_FUNC_END;
 196
 197         return layout;
 198 }
 199
 200 static Evas_Object *__search_create_navigation_layout(Evas_Object * parent)
 201 {
 202         SEARCH_FUNC_START;
 203
 204         Evas_Object *navi_bar;  //, *sd;
 205
 206         SEARCH_RETV_IF(parent == NULL, NULL);
 207
 208         navi_bar = elm_naviframe_add(parent);
 209
 210         elm_object_part_content_set(parent, "elm.swallow.content", navi_bar);
 211
 212         evas_object_show(navi_bar);
 213
 214         SEARCH_FUNC_END;
 215
 216         return navi_bar;
 217 }
 218
 219 static void __search_back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 220 {
 221         SEARCH_FUNC_START;
 222
 223         struct appdata *ad = (struct appdata *)data;
 224         SEARCH_RET_IF(ad == NULL);
 225
 226         elm_win_lower(ad->win_main);
 227
 228         if(ad->back_btn_type == BACK_BTN_TYPE_CLOSE)
 229                 elm_exit();
 230
 231         SEARCH_FUNC_END;
 232 }
 233
 234 static Evas_Object* __search_add_back_btn(struct appdata *ad)
 235 {
 236         SEARCH_FUNC_START;
 237         SEARCH_RETV_IF(ad == NULL, NULL);
 238
 239         /* add back key */
 240         Evas_Object *btn = elm_button_add(ad->conformant);
 241         elm_object_style_set(btn, "naviframe/end_btn/default");
 242         evas_object_smart_callback_add(btn, "clicked", __search_back_btn_clicked_cb, ad);
 243
 244         SEARCH_FUNC_END;
 245
 246         return btn;
 247 }
 248
 249 static int __search_init_smartsearch(struct appdata *ad)
 250 {
 251         SEARCH_FUNC_START;
 252
 253         SEARCH_RETV_IF(ad == NULL, -1);
 254
 255         // Base Layout
 256         ad->bg = __search_create_bg(ad->win_main);
 257         ad->conformant = __search_create_conformant(ad->win_main);
 258         ad->layout_main = __search_create_layout_main(ad->conformant, ad->bg);
 259         SEARCH_RETV_IF(ad->layout_main == NULL, -1);
 260         elm_object_content_set(ad->conformant, ad->layout_main);
 261
 262         // Indicator
 263         elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_SHOW);
 264
 265         // Navigation Bar
 266         ad->navi_bar = __search_create_navigation_layout(ad->layout_main);
 267
 268         // Backbutton
 269         ad->back_btn = __search_add_back_btn(ad);
 270
 271         // Search bar layout
 272         search_create_searchbar_layout(ad->conformant, ad);
 273
 274         ad->navi_it = elm_naviframe_item_push(ad->navi_bar,
 275                                dgettext("sys_string", "IDS_COM_BODY_SEARCH"),
 276                                ad->back_btn, NULL, ad->sb_layout, NULL);
 277
 278         ad->search_category = SEARCH_CATE_PHONE;
 279
 280         SEARCH_FUNC_END;
 281
 282         return 0;
 283 }
 284
 285 static void __search_init_category_object(struct appdata *ad)
 286 {
 287         SEARCH_FUNC_START;
 288         int i = 0;
 289
 290         SEARCH_RET_IF(ad == NULL);
 291
 292         /* Initialize Category */
 293         for( i = 0 ; i < SEARCH_CATE_MAX; ++i ) {
 294                 ad->category_info[i].btn_icon_path = strdup(def_category[i].btn_icon_path);
 295                 ad->category_info[i].btn_icon_press_path = strdup(def_category[i].btn_icon_press_path);
 296         }
 297
 298         SEARCH_FUNC_END;
 299 }
 300
 301 static void __search_init_result_object(struct appdata *ad)
 302 {
 303         SEARCH_FUNC_START;
 304
 305         int i = 0;
 306         int rc = 0;
 307         int ret = SEARCH_RET_SEARCH_NONE;
 308
 309         int ail_ret = 0;
 310
 311         sqlite3_stmt *sql_load = NULL;
 312         sqlite3_stmt *sql_insert = NULL;
 313
 314         char *imgpath = NULL;
 315
 316         /* Load DB data */
 317         sql_load = ad->search_db_sql[SEARCH_STMT_GET_CATEGORY_LIST_ALL];
 318
 319         rc = sqlite3_step(sql_load);
 320         if (rc != SQLITE_ROW) {
 321                 if (rc == SQLITE_DONE) {
 322                         SEARCH_DEBUG_WARNING("SELECT STEP : SQLITE_DONE. No result");
 323                         ret = SEARCH_RET_SEARCH_NONE;
 324                 } else {
 325                         SEARCH_DEBUG_ERROR("SELECT STEP FAIL : (%d)", rc);
 326                         ret = SEARCH_RET_SEARCH_FAIL;
 327                 }
 328         } else {
 329                 SEARCH_DEBUG_LOG("SELECT STEP SUCCESS");
 330                 ret = SEARCH_RET_SEARCH_SUCCESS;
 331 }
 332
 333         if( ret != SEARCH_RET_SEARCH_SUCCESS ) {
 334                 /* If db result is NULL, initialize to default setting and insert this data to DB */
 335                 for( i = 0; i < SEARCH_CONT_MAX ; ++i ) {
 336                         sql_insert = ad->search_db_sql[SEARCH_STMT_INSERT_OBJECT_INFO];
 337                         ad->result_obj[i].order = def_obj[i].order;
 338                         ad->result_obj[i].visible = def_obj[i].visible;
 339                         ad->result_obj[i].contents_type = def_obj[i].contents_type;
 340                         ad->result_obj[i].category_type = def_obj[i].category_type;
 341                         ad->result_obj[i].name = strdup(def_obj[i].name);
 342                         ad->result_obj[i].string_type = def_obj[i].string_type;
 343                         ad->result_obj[i].def_pkg_name = strdup(def_obj[i].def_pkg_name);
 344                         ail_ret = app_manager_get_app_icon_path(def_obj[i].def_pkg_name, &imgpath);
 345
 346                         if (ail_ret == APP_MANAGER_ERROR_NONE && imgpath) {
 347                                 ad->result_obj[i].obj_icon_path = strdup(imgpath);
 348                                 SEARCH_FREE(imgpath);
 349 }
 350
 351                         /* Insert DB */
 352                         search_sql_bind_text(ad->search_db_hd, sql_insert, 1, ad->result_obj[i].name);
 353                         search_sql_bind_int(ad->search_db_hd, sql_insert, 2, ad->result_obj[i].string_type);
 354                         search_sql_bind_int(ad->search_db_hd, sql_insert, 3, ad->result_obj[i].visible);
 355                         search_sql_bind_int(ad->search_db_hd, sql_insert, 4, ad->result_obj[i].order);
 356                         search_sql_bind_int(ad->search_db_hd, sql_insert, 5, ad->result_obj[i].contents_type);
 357                         search_sql_bind_int(ad->search_db_hd, sql_insert, 6, ad->result_obj[i].category_type);
 358                         search_sql_bind_text(ad->search_db_hd, sql_insert, 7, ad->result_obj[i].def_pkg_name);
 359
 360                         rc = sqlite3_step(sql_insert);
 361
 362                         if( sql_insert != NULL )
 363                                 search_sql_stmt_init(sql_insert);
 364                 }
 365         } else {
 366                 /* Copy db data to structure */
 367                 for(i = 0; i < SEARCH_CONT_MAX && rc == SQLITE_ROW; ++i) {
 368                         char *name = (char *)sqlite3_column_text(sql_load, 0);
 369                         int string_type = sqlite3_column_int(sql_load, 1);
 370                         int visible = sqlite3_column_int(sql_load, 2);
 371                         int order = sqlite3_column_int(sql_load, 3);
 372                         int contents_type = sqlite3_column_int(sql_load, 4);
 373                         int category_type = sqlite3_column_int(sql_load, 5);
 374                         char *def_pkg_name = (char *)sqlite3_column_text(sql_load, 6);
 375
 376                         ad->result_obj[i].order = order;
 377                         ad->result_obj[i].contents_type = contents_type;
 378                         ad->result_obj[i].string_type = string_type;
 379                         ad->result_obj[i].category_type = category_type;
 380                         ad->result_obj[i].name = ( name != NULL ) ? strdup(name): NULL;
 381                         ad->result_obj[i].visible = ( visible > 0 ) ? EINA_TRUE : EINA_FALSE;
 382                         ad->result_obj[i].def_pkg_name = ( def_pkg_name != NULL) ?
 383                                                                                         strdup(def_pkg_name) : NULL;
 384
 385                         if (def_pkg_name) {
 386                                 ail_ret = app_manager_get_app_icon_path(def_obj[i].def_pkg_name, &imgpath);
 387
 388                                 if (ail_ret == APP_MANAGER_ERROR_NONE && imgpath) {
 389                                         ad->result_obj[i].obj_icon_path = strdup(imgpath);
 390                                         SEARCH_FREE(imgpath);
 391                                 }
 392                         }
 393
 394                         rc = sqlite3_step(sql_load);
 395                                         }
 396                         }
 397
 398         if( sql_load != NULL )
 399                 search_sql_stmt_init(sql_load);
 400         if( sql_insert != NULL )
 401                 search_sql_stmt_init(sql_insert);
 402
 403         SEARCH_FUNC_END;
 404                                 }
 405
 406 static Evas_Object *__search_create_win(const char *name, void *data)
 407                         {
 408         SEARCH_FUNC_START;
 409
 410         struct appdata *ad = (struct appdata *)data;
 411         Evas_Object *eo;
 412         int w, h;
 413
 414         SEARCH_RETV_IF(ad == NULL, NULL);
 415
 416         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 417         elm_win_conformant_set(eo, EINA_TRUE);
 418
 419         if (eo) {
 420                 elm_win_title_set(eo, name);
 421                 evas_object_smart_callback_add(eo, "delete,request",
 422                                                __search_win_delete_cb, ad);
 423                 ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, &h);
 424                 evas_object_resize(eo, w, h);
 425         }
 426
 427         SEARCH_FUNC_END;
 428
 429         return eo;
 430 }
 431
 432 static int __search_init_db_connect(struct appdata *ad)
 433 {
 434         SEARCH_FUNC_START;
 435
 436         int rc = 0;
 437         int ret = SEARCH_RET_FAIL;
 438
 439         SEARCH_RETV_IF(ad == NULL, SEARCH_RET_FAIL);
 440
 441         rc = db_util_open(SEARCH_DB_PATH,
 442                                                        &(ad->search_db_hd),
 443                                                        0);
 444         if (rc != SQLITE_OK) {
 445                 SEARCH_DEBUG_ERROR
 446                     ("db_util_open error : %d (%s)\n",
 447                      rc, SEARCH_DB_PATH);
 448                 ret = SEARCH_RET_FAIL;
 449         } else {
 450                 int i = 0;
 451                 const char *query_list[SEARCH_STMT_MAX] = {                             SEARCH_DB_SQL_GET_CATEGORY_LIST_ALL,
 452                                                                                         SEARCH_DB_SQL_INSERT_OBJECT_IFNO,
 453                                                                                         SEARCH_DB_SQL_UPDATE_OBJECT_INFO
 454                 };
 455
 456                 for (i = SEARCH_STMT_GET_CATEGORY_LIST_ALL; i < SEARCH_STMT_MAX ; ++i ) {
 457                         SEARCH_DEBUG_LOG("query : %s\n", query_list[i]);
 458
 459                         ret = search_sql_prepare_stmt(ad->search_db_hd, query_list[i],
 460                                 &(ad->search_db_sql[i]));
 461                 }
 462         }
 463
 464         SEARCH_FUNC_END;
 465
 466         return ret;
 467 }
 468
 469 static void __search_deinit_db_connect(struct appdata *ad)
 470                         {
 471         SEARCH_FUNC_START;
 472
 473         int i = 0, rc = 0;
 474
 475         SEARCH_RET_IF(ad == NULL);
 476
 477         for (i = SEARCH_STMT_GET_CATEGORY_LIST_ALL; i < SEARCH_STMT_MAX ; ++i ) {
 478                 if (ad->search_db_sql[i]) {
 479                         search_sql_stmt_finalize(ad->search_db_sql[i]);
 480                         ad->search_db_sql[i] = NULL;
 481                                 }
 482                         }
 483
 484         if (ad->search_db_hd) {
 485                 rc = db_util_close(ad->search_db_hd);
 486                 if (rc != SQLITE_OK) {
 487                                         SEARCH_DEBUG_WARNING
 488                             ("db_util_close error : %d / %s",
 489                              rc, SEARCH_DB_PATH);
 490                 } else {
 491                         SEARCH_DEBUG_LOG("db_util_close success");
 492                 }
 493                 ad->search_db_hd = NULL;
 494         } else {
 495                 SEARCH_DEBUG_WARNING("db_handle(%s) is null", SEARCH_DB_PATH);
 496         }
 497
 498         SEARCH_FUNC_END;
 499 }
 500
 501 static Eina_Bool __search_init_after_ui_create(gpointer data)
 502 {
 503         SEARCH_FUNC_START;
 504
 505         struct appdata *ad = (struct appdata *)data;
 506         SEARCH_RETV_IF(ad == NULL, ECORE_CALLBACK_CANCEL);
 507
 508         ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
 509                                                         __search_keydown_event,
 510                                                         ad);
 511
 512         ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
 513                                                         __search_mousedown_event,
 514                                                         ad);
 515
 516         __search_init_db_connect(ad);
 517         __search_init_result_object(ad);
 518
 519         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 520
 521         SEARCH_FUNC_END;
 522
 523         return ECORE_CALLBACK_CANCEL;
 524 }
 525
 526
 527 static void __search_update_lang(void *data)
 528 {
 529         SEARCH_FUNC_START;
 530         struct appdata *ad = (struct appdata *)data;
 531         int i = 0;
 532
 533         SEARCH_RET_IF(ad == NULL);
 534
 535         /* Update Text for match to current language */
 536         if (ad->navi_it)
 537                 elm_object_item_text_set(ad->navi_it,
 538                                                         dgettext("sys_string", "IDS_COM_BODY_SEARCH"));
 539
 540         if (ad->search_bar)
 541                 elm_object_part_text_set(ad->search_bar,
 542                                                         "elm.guidetext",
 543                                                         dgettext("sys_string", "IDS_COM_BODY_SEARCH"));
 544         if (ad->noresult_view)
 545                 elm_object_part_text_set(ad->noresult_view,
 546                                                         "elm.text",
 547                                                         dgettext("sys_string", "IDS_COM_BODY_NO_SEARCH_RESULTS"));
 548
 549         if (ad->search_cancel_btn)
 550                 elm_object_text_set(ad->search_cancel_btn,
 551                                                         dgettext("sys_string",
 552                                                         "IDS_COM_SK_CANCEL"));
 553
 554         for (i = 0; i < SEARCH_CONT_MAX; i++) {
 555                 Elm_Object_Item *it = ad->result_obj[i].gl_result_grp;
 556                 const char *item_name = ad->result_obj[i].name;
 557
 558                 if (it && item_name)
 559                         elm_genlist_item_fields_update(it, "elm.text", ELM_GENLIST_ITEM_FIELD_TEXT);
 560         }
 561
 562         SEARCH_FUNC_END;
 563 }
 564
 565 static bool __search_app_create(void *data)
 566 {
 567         SEARCH_FUNC_START;
 568
 569         struct appdata *ad = (struct appdata *)data;
 570
 571         SEARCH_RETV_IF(ad == NULL, false);
 572
 573         ad->win_main = __search_create_win(SEARCH_PACKAGE, ad);
 574         SEARCH_RETV_IF(ad->win_main == NULL, -1);
 575
 576         evas_object_show(ad->win_main);
 577
 578         ad->scale_factor = elm_config_scale_get();
 579
 580         __search_init_category_object(ad);
 581         __search_init_smartsearch(ad);
 582
 583         ad->first_search = true;
 584         ad->idler_create_ui = ecore_idler_add(__search_init_after_ui_create, ad);
 585         evas_object_show(ad->win_main);
 586
 587         SEARCH_FUNC_END;
 588
 589         return true;
 590 }
 591
 592 static void __search_app_terminate(void *data)
 593 {
 594         SEARCH_FUNC_START;
 595
 596         struct appdata *ad = (struct appdata *)data;
 597         int i = 0;
 598
 599         SEARCH_RET_IF(ad == NULL);
 600
 601         if (ad->layout_main) {
 602                 evas_object_del(ad->layout_main);
 603                 ad->layout_main = NULL;
 604         }
 605
 606         if (ad->win_main) {
 607                 evas_object_del(ad->win_main);
 608                 ad->win_main = NULL;
 609         }
 610
 611         if(ad->idler_create_ui)
 612                 ecore_idler_del(ad->idler_create_ui);
 613
 614         search_result_gl_deinit(ad);
 615
 616         search_app_disconnect(ad);
 617         __search_deinit_db_connect(ad);
 618
 619         search_util_date_time_format_deinit();
 620
 621         for ( i = 0 ; i < SEARCH_CONT_MAX ; ++i ) {
 622                 SEARCH_FREE(ad->result_obj[i].name);
 623                 SEARCH_FREE(ad->result_obj[i].obj_icon_path);
 624                 SEARCH_FREE(ad->result_obj[i].def_pkg_name);
 625         }
 626
 627         for ( i = 0 ; i < SEARCH_CATE_MAX ; ++i ) {
 628                 SEARCH_FREE(ad->category_info[i].btn_icon_path);
 629                 SEARCH_FREE(ad->category_info[i].btn_icon_press_path);
 630         }
 631
 632         SEARCH_FREE(ad->search_word);
 633         SEARCH_FREE(ad->not_markup_search_word);
 634
 635         SEARCH_FUNC_END;
 636 }
 637
 638 static void __search_app_pause(void *data)
 639 {
 640         SEARCH_FUNC_START;
 641
 642         SEARCH_FUNC_END;
 643 }
 644
 645 static void __search_app_resume(void *data)
 646 {
 647         SEARCH_FUNC_START;
 648
 649         struct appdata *ad = (struct appdata *)data;
 650         SEARCH_RET_IF(ad == NULL);
 651
 652         if (ad->win_main) {
 653                 elm_object_focus_set(ad->back_btn, EINA_FALSE);
 654         }
 655
 656         elm_genlist_select_mode_set(ad->search_gl, ELM_OBJECT_SELECT_MODE_DEFAULT);
 657
 658         if (elm_object_scroll_freeze_get(ad->search_gl) > 0) {
 659                 elm_object_scroll_freeze_pop(ad->search_gl);
 660         }
 661
 662         SEARCH_FUNC_END;
 663 }
 664
 665 static void __search_app_service(service_h service, void *data)
 666 {
 667         SEARCH_FUNC_START;
 668
 669         struct appdata *ad = (struct appdata *)data;
 670
 671         char *query = NULL;
 672         char *keyword = NULL;
 673         char *operation = NULL;
 674
 675         Evas_Object *cate_icon;
 676         int ret = 0;
 677         char *icon_path = NULL;
 678
 679         ad->back_btn_type = BACK_BTN_TYPE_LOWER;
 680         SEARCH_FREE(ad->search_word);
 681
 682         ret = service_get_operation(service, &operation);
 683
 684         if (ret != 0) {
 685                 SEARCH_DEBUG_WARNING("Cannot get operation!");
 686                 return;
 687         }
 688
 689         if(operation == NULL ) {
 690                 SEARCH_DEBUG_WARNING("Operation is NULL!");
 691                 return;
 692                         }
 693
 694         SEARCH_DEBUG_LOG("SERVICE OPERATION TYPE : %s", operation);
 695         if (SEARCH_STRCMP(operation, SERVICE_OPERATION_SEARCH) == 0) {
 696                 ret = service_get_extra_data(service, "http://tizen.org/appcontrol/data/keyword", &query);
 697
 698                 if(ret != 0) {
 699                         SEARCH_DEBUG_WARNING("Fail to Get Keyword data!");
 700                         query = NULL;
 701                         }
 702
 703                 if( (query) && (strlen(query) > 0) ) {
 704                         keyword = (char*)malloc(strlen(query)+1);
 705                         memset(keyword, 0x00, strlen(query)+1);
 706                         strncpy(keyword, query, strlen(query));
 707                 }
 708
 709                 ad->search_category = SEARCH_CATE_PHONE;
 710                 ad->back_btn_type = BACK_BTN_TYPE_CLOSE;
 711
 712         } else {
 713                 /* If Operation type is not SEARCH, Initializae valute to default */
 714                         keyword = vconf_get_str(SMARTSEARCH_KEY_KEYWORD);
 715
 716                 if (keyword == NULL)
 717                         SEARCH_DEBUG_WARNING("Error(%d) : get current key from vconf", ret);
 718
 719                 ad->search_category = SEARCH_CATE_PHONE;
 720         }
 721
 722         SEARCH_DEBUG_LOG("current category : %d", ad->search_category);
 723
 724         icon_path = ad->category_info[ad->search_category].btn_icon_path;
 725         cate_icon = search_searchbar_category_icon_add(icon_path,
 726                 ad->sb_layout,
 727                 SEARCH_CATEGORY_BTN_ICON_SIZE_WIDTH,
 728                 SEARCH_CATEGORY_BTN_ICON_SIZE_HEIGHT,
 729                 false);
 730         elm_object_content_set(ad->cate_btn, cate_icon);
 731
 732         /* set current category to vconf */
 733         ad->search_category = SEARCH_CATE_PHONE;
 734
 735         if ((keyword) && (strlen(keyword) > 0)) {
 736                 elm_object_text_set(ad->search_entry, keyword);
 737         } else {
 738                 SEARCH_DEBUG_LOG("keyword is NULL");
 739
 740                 elm_object_text_set(ad->search_entry, "");
 741                 elm_object_signal_emit(ad->search_bar, "cancel,hide", "");
 742
 743                 search_set_result_list(ad);
 744
 745                 /* set focus to entry for launching ime */
 746                 evas_object_show(ad->search_entry);
 747                 elm_object_focus_set(ad->search_entry,EINA_TRUE);
 748                 elm_object_signal_emit(ad->search_bar, "cancel,in", "");
 749         }
 750
 751         SEARCH_FREE(keyword);
 752         SEARCH_FREE(operation);
 753         SEARCH_FREE(query);
 754
 755         elm_entry_cursor_end_set(ad->search_entry);
 756
 757         if (ad->win_main)
 758                 elm_win_activate(ad->win_main);
 759
 760         SEARCH_FUNC_END;
 761 }
 762
 763 static void __search_app_device_orientation_cb(app_device_orientation_e orientation, void *data)
 764 {
 765         SEARCH_FUNC_START;
 766         struct appdata *ad = (struct appdata *)data;
 767         SEARCH_RET_IF(ad == NULL);
 768         SEARCH_RET_IF(ad->win_main == NULL);
 769
 770         if (orientation >= 0) {
 771                 elm_win_rotation_with_resize_set(ad->win_main, orientation);
 772         }
 773
 774         SEARCH_FUNC_END;
 775 }
 776
 777 static void __search_app_lang_change(void *data)
 778 {
 779         SEARCH_FUNC_START;
 780         struct appdata *ad = (struct appdata *)data;
 781
 782         __search_update_lang(ad);
 783
 784         SEARCH_FUNC_END;
 785 }
 786
 787 int main(int argc, char *argv[])
 788 {
 789         SEARCH_FUNC_START;
 790
 791         struct appdata ad;
 792
 793         int i = 0;
 794
 795         app_event_callback_s event_callback;
 796
 797         event_callback.create = __search_app_create;
 798         event_callback.terminate = __search_app_terminate;
 799         event_callback.pause = __search_app_pause;
 800         event_callback.resume = __search_app_resume;
 801         event_callback.service = __search_app_service;
 802         event_callback.low_memory = NULL;
 803         event_callback.low_battery = NULL;
 804         event_callback.device_orientation = __search_app_device_orientation_cb;
 805         event_callback.language_changed = __search_app_lang_change;
 806         event_callback.region_format_changed = search_region_format_cb;
 807
 808         memset(&ad, 0x0, sizeof(struct appdata));
 809
 810         for (i = 0; i < argc; i++)
 811                 SEARCH_DEBUG_LOG("argv[%d] = [%s]\n", i, argv[i]);
 812
 813         SEARCH_FUNC_END;
 814
 815         return app_efl_main(&argc, &argv, &event_callback, &ad);
 816 }