src/smartsearch.cpp

   1 /*
   2  * Copyright 2012  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://www.tizenopensource.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 <ail.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.efl-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
  92         Ecore_Event_Mouse_Button *ev = (Ecore_Event_Mouse_Button *) event;
  93         ad->touch_x = ev->x;
  94         ad->touch_y = ev->y;
  95         return ECORE_CALLBACK_CANCEL;
  96 }
  97
  98
  99 static Eina_Bool __search_keydown_event(void *data, int type, void *event)
 100 {
 101         SEARCH_FUNC_START;
 102
 103         Ecore_Event_Key *ev = (Ecore_Event_Key *) event;
 104
 105         if (!SEARCH_STRCMP(ev->keyname, KEY_END)) {
 106                 //end key concept is close.
 107                 elm_exit();
 108         }
 109
 110         SEARCH_FUNC_END;
 111
 112         return EINA_FALSE;
 113 }
 114
 115 static Evas_Object *__search_create_layout_main(Evas_Object * parent)
 116 {
 117         SEARCH_FUNC_START;
 118
 119         Evas_Object *layout;
 120         Evas_Object *bg;
 121
 122         SEARCH_RETV_IF(parent == NULL, NULL);
 123
 124         layout = elm_layout_add(parent);
 125
 126         SEARCH_RETV_IF(layout == NULL, NULL);
 127
 128         //elm_layout_theme_set(layout, "standard", "window", "integration");
 129         elm_layout_theme_set(layout, "layout", "application", "default");
 130
 131         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 132         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 133         elm_win_resize_object_add(parent, layout);
 134
 135         bg = elm_bg_add(parent);
 136         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 137         elm_win_resize_object_add(parent, bg);
 138         elm_object_part_content_set(layout, "elm.swallow.bg", bg);
 139
 140     evas_object_show(bg);
 141
 142         edje_object_signal_emit(_EDJ(layout), "elm,state,show,indicator","elm");
 143         edje_object_signal_emit(_EDJ(layout), "elm,state,show,content", "elm");
 144         evas_object_show(layout);
 145
 146         SEARCH_FUNC_END;
 147
 148         return layout;
 149 }
 150
 151 static Evas_Object *__search_create_navigation_layout(Evas_Object * parent)
 152 {
 153         SEARCH_FUNC_START;
 154
 155         Evas_Object *navi_bar;  //, *sd;
 156
 157         SEARCH_RETV_IF(parent == NULL, NULL);
 158
 159         navi_bar = elm_naviframe_add(parent);
 160
 161         elm_object_part_content_set(parent, "elm.swallow.content", navi_bar);
 162
 163         evas_object_show(navi_bar);
 164
 165         SEARCH_FUNC_END;
 166
 167         return navi_bar;
 168 }
 169
 170 static void __search_back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 171 {
 172         SEARCH_FUNC_START;
 173
 174         struct appdata *ad = (struct appdata *)data;
 175
 176                 elm_win_lower(ad->win_main);
 177
 178         if(ad->back_btn_type == BACK_BTN_TYPE_CLOSE)
 179                 elm_exit();
 180
 181         SEARCH_FUNC_END;
 182 }
 183
 184 static void __search_add_back_btn(struct appdata *ad)
 185 {
 186         SEARCH_FUNC_START;
 187
 188         /* add back key */
 189         Evas_Object *btn = elm_button_add(ad->navi_bar);
 190         elm_object_style_set(btn, "naviframe/end_btn/default");
 191         evas_object_smart_callback_add(btn, "clicked", __search_back_btn_clicked_cb, ad);
 192
 193 #ifdef __ENABLE_TOP_BACK_BTN
 194         ad->navi_it = elm_naviframe_item_push(ad->navi_bar,
 195                                dgettext("sys_string", "IDS_COM_BODY_SEARCH"),
 196                                NULL, NULL, ad->sb_layout, NULL);
 197
 198         elm_object_item_part_content_set(navi_it, "title_right_btn", btn);
 199         elm_object_item_signal_emit(navi_it, "elm,state,controlbar,close", "");
 200 #else
 201         ad->navi_it = elm_naviframe_item_push(ad->navi_bar,
 202                                dgettext("sys_string", "IDS_COM_BODY_SEARCH"),
 203                                btn, NULL, ad->sb_layout, NULL);
 204 #endif
 205
 206         ad->back_btn = btn;
 207
 208         SEARCH_FUNC_END;
 209 }
 210
 211 static int __search_init_smartsearch(struct appdata *ad)
 212 {
 213         SEARCH_FUNC_START;
 214
 215         SEARCH_RETV_IF(ad == NULL, -1);
 216
 217         // Base Layout
 218         ad->layout_main = __search_create_layout_main(ad->win_main);
 219         SEARCH_RETV_IF(ad->layout_main == NULL, -1);
 220
 221         // Indicator
 222         elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_SHOW);
 223
 224         // Navigation Bar
 225         ad->navi_bar = __search_create_navigation_layout(ad->layout_main);
 226
 227         ad->search_category = SEARCH_CATE_PHONE;
 228         search_searchbar_cb(ad, NULL, NULL);
 229
 230         __search_add_back_btn(ad);
 231         SEARCH_FUNC_END;
 232
 233         return 0;
 234 }
 235
 236 static void __search_init_category_object(struct appdata *ad)
 237 {
 238         SEARCH_FUNC_START;
 239         int i = 0;
 240
 241         /* Initialize Category */
 242         for( i = 0 ; i < SEARCH_CATE_MAX; ++i ) {
 243                 ad->category_info[i].btn_icon_path = strdup(def_category[i].btn_icon_path);
 244                 ad->category_info[i].btn_icon_press_path = strdup(def_category[i].btn_icon_press_path);
 245         }
 246
 247         SEARCH_FUNC_END;
 248 }
 249
 250 static void __search_init_result_object(struct appdata *ad)
 251 {
 252         SEARCH_FUNC_START;
 253
 254         int i = 0;
 255         int rc = 0;
 256         int ret = SEARCH_RET_SEARCH_NONE;
 257
 258         ail_appinfo_h handle = NULL;
 259         ail_error_e ail_ret = AIL_ERROR_OK;
 260         char *str = NULL;
 261
 262         sqlite3_stmt *sql_load = NULL;
 263         sqlite3_stmt *sql_insert = NULL;
 264
 265         /* Load DB data */
 266         sql_load = ad->search_db_sql[SEARCH_STMT_GET_CATEGORY_LIST_ALL];
 267
 268         rc = sqlite3_step(sql_load);
 269         if (rc != SQLITE_ROW) {
 270                 if (rc == SQLITE_DONE) {
 271                         SEARCH_DEBUG_WARNING("SELECT STEP : SQLITE_DONE. No result");
 272                         ret = SEARCH_RET_SEARCH_NONE;
 273                 } else {
 274                         SEARCH_DEBUG_ERROR("SELECT STEP FAIL : (%d)", rc);
 275                         ret = SEARCH_RET_SEARCH_FAIL;
 276                 }
 277         } else {
 278                 SEARCH_DEBUG_LOG("SELECT STEP SUCCESS");
 279                 ret = SEARCH_RET_SEARCH_SUCCESS;
 280 }
 281
 282         if( ret != SEARCH_RET_SEARCH_SUCCESS ) {
 283                 /* If db result is NULL, initialize to default setting and insert this data to DB */
 284                 for( i = 0; i < SEARCH_CONT_MAX ; ++i ) {
 285                         sql_insert = ad->search_db_sql[SEARCH_STMT_INSERT_OBJECT_INFO];
 286                         ad->result_obj[i].order = def_obj[i].order;
 287                         ad->result_obj[i].visible = def_obj[i].visible;
 288                         ad->result_obj[i].contents_type = def_obj[i].contents_type;
 289                         ad->result_obj[i].category_type = def_obj[i].category_type;
 290                         ad->result_obj[i].name = strdup(def_obj[i].name);
 291                         ad->result_obj[i].string_type = def_obj[i].string_type;
 292                         ad->result_obj[i].def_pkg_name = strdup(def_obj[i].def_pkg_name);
 293
 294                         ail_ret = ail_package_get_appinfo(def_obj[i].def_pkg_name, &handle);
 295
 296                         if (ail_ret == AIL_ERROR_OK) {
 297                                 ret = ail_appinfo_get_str(handle, AIL_PROP_ICON_STR, &str);
 298
 299                                 if (ail_ret == AIL_ERROR_OK)
 300                                         ad->result_obj[i].obj_icon_path = strdup(str);
 301 }
 302
 303                         /* Insert DB */
 304                         search_sql_bind_text(ad->search_db_hd, sql_insert, 1, ad->result_obj[i].name);
 305                         search_sql_bind_int(ad->search_db_hd, sql_insert, 2, ad->result_obj[i].string_type);
 306                         search_sql_bind_int(ad->search_db_hd, sql_insert, 3, ad->result_obj[i].visible);
 307                         search_sql_bind_int(ad->search_db_hd, sql_insert, 4, ad->result_obj[i].order);
 308                         search_sql_bind_int(ad->search_db_hd, sql_insert, 5, ad->result_obj[i].contents_type);
 309                         search_sql_bind_int(ad->search_db_hd, sql_insert, 6, ad->result_obj[i].category_type);
 310                         search_sql_bind_text(ad->search_db_hd, sql_insert, 7, ad->result_obj[i].def_pkg_name);
 311
 312                         rc = sqlite3_step(sql_insert);
 313
 314                         if( sql_insert != NULL )
 315                                 search_sql_stmt_init(sql_insert);
 316                 }
 317         } else {
 318                 /* Copy db data to structure */
 319                 for(i = 0; i < SEARCH_CONT_MAX && rc == SQLITE_ROW; ++i) {
 320                         char *name = (char *)sqlite3_column_text(sql_load, 0);
 321                         int string_type = sqlite3_column_int(sql_load, 1);
 322                         int visible = sqlite3_column_int(sql_load, 2);
 323                         int order = sqlite3_column_int(sql_load, 3);
 324                         int contents_type = sqlite3_column_int(sql_load, 4);
 325                         int category_type = sqlite3_column_int(sql_load, 5);
 326                         char *def_pkg_name = (char *)sqlite3_column_text(sql_load, 6);
 327
 328                         ad->result_obj[i].order = order;
 329                         ad->result_obj[i].contents_type = contents_type;
 330                         ad->result_obj[i].string_type = string_type;
 331                         ad->result_obj[i].category_type = category_type;
 332                         ad->result_obj[i].name = ( name != NULL ) ? strdup(name): NULL;
 333                         ad->result_obj[i].visible = ( visible > 0 ) ? EINA_TRUE : EINA_FALSE;
 334                         ad->result_obj[i].def_pkg_name = ( def_pkg_name != NULL) ?
 335                                                                                         strdup(def_pkg_name) : NULL;
 336
 337                         if (def_pkg_name) {
 338                                 ail_ret = ail_package_get_appinfo(def_pkg_name, &handle);
 339
 340                                 if (ail_ret == AIL_ERROR_OK) {
 341                                         ret = ail_appinfo_get_str(handle, AIL_PROP_ICON_STR, &str);
 342
 343                                         if (ail_ret == AIL_ERROR_OK)
 344                                                 ad->result_obj[i].obj_icon_path = strdup(str);
 345                                 }
 346                         }
 347
 348                         rc = sqlite3_step(sql_load);
 349                                         }
 350                         }
 351
 352         if( sql_load != NULL )
 353                 search_sql_stmt_init(sql_load);
 354         if( sql_insert != NULL )
 355                 search_sql_stmt_init(sql_insert);
 356
 357         SEARCH_FUNC_END;
 358                                 }
 359
 360 static Evas_Object *__search_create_win(const char *name)
 361                         {
 362         SEARCH_FUNC_START;
 363
 364         Evas_Object *eo;
 365
 366         eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 367         if (eo) {
 368                 elm_win_title_set(eo, name);
 369                 evas_object_smart_callback_add(eo, "delete,request",
 370                                                __search_win_delete_cb, NULL);
 371         }
 372
 373         SEARCH_FUNC_END;
 374
 375         return eo;
 376 }
 377
 378 static int __search_init_db_connect(struct appdata *ad)
 379 {
 380         SEARCH_FUNC_START;
 381
 382         int rc = 0;
 383         int ret = SEARCH_RET_FAIL;
 384
 385         rc = db_util_open(SEARCH_DB_PATH,
 386                                                        &(ad->search_db_hd),
 387                                                        0);
 388         if (rc != SQLITE_OK) {
 389                 SEARCH_DEBUG_ERROR
 390                     ("db_util_open error : %d (%s)\n",
 391                      rc, SEARCH_DB_PATH);
 392                 ret = SEARCH_RET_FAIL;
 393         } else {
 394                 int i = 0;
 395                 const char *query_list[SEARCH_STMT_MAX] = {                             SEARCH_DB_SQL_GET_CATEGORY_LIST_ALL,
 396                                                                                         SEARCH_DB_SQL_INSERT_OBJECT_IFNO,
 397                                                                                         SEARCH_DB_SQL_UPDATE_OBJECT_INFO
 398                 };
 399
 400                 for (i = SEARCH_STMT_GET_CATEGORY_LIST_ALL; i < SEARCH_STMT_MAX ; ++i ) {
 401                         SEARCH_DEBUG_LOG("query : %s\n", query_list[i]);
 402
 403                         ret = search_sql_prepare_stmt(ad->search_db_hd, query_list[i],
 404                                 &(ad->search_db_sql[i]));
 405                                 }
 406                         }
 407
 408         return ret;
 409
 410         SEARCH_FUNC_END;
 411                                 }
 412
 413 static void __search_deinit_db_connect(struct appdata *ad)
 414                         {
 415         SEARCH_FUNC_START;
 416
 417         int i = 0, rc = 0;
 418
 419         for (i = SEARCH_STMT_GET_CATEGORY_LIST_ALL; i < SEARCH_STMT_MAX ; ++i ) {
 420                 if (ad->search_db_sql[i]) {
 421                         search_sql_stmt_finalize(ad->search_db_sql[i]);
 422                         ad->search_db_sql[i] = NULL;
 423                                 }
 424                         }
 425
 426         if (ad->search_db_hd) {
 427                 rc = db_util_close(ad->search_db_hd);
 428                 if (rc != SQLITE_OK) {
 429                                         SEARCH_DEBUG_WARNING
 430                             ("db_util_close error : %d / %s",
 431                              rc, SEARCH_DB_PATH);
 432                 } else {
 433                         SEARCH_DEBUG_LOG("db_util_close success");
 434                 }
 435                 ad->search_db_hd = NULL;
 436         } else {
 437                 SEARCH_DEBUG_WARNING("db_handle(%s) is null", SEARCH_DB_PATH);
 438         }
 439
 440         SEARCH_FUNC_END;
 441 }
 442
 443 static Eina_Bool __search_init_after_ui_create(gpointer data)
 444 {
 445         SEARCH_FUNC_START;
 446
 447         struct appdata *ad = (struct appdata *)data;
 448
 449         ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
 450                                                         __search_keydown_event,
 451                                                         ad);
 452
 453         ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
 454                                                         __search_mousedown_event,
 455                                                         ad);
 456
 457         __search_init_db_connect(ad);
 458         __search_init_result_object(ad);
 459         search_app_connect(ad);
 460
 461         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 462
 463         SEARCH_FUNC_END;
 464
 465         return ECORE_CALLBACK_CANCEL;
 466 }
 467
 468
 469 static void __search_update_lang(void *data)
 470 {
 471         SEARCH_FUNC_START;
 472         struct appdata *ad = (struct appdata *)data;
 473         int i = 0;
 474
 475         /* Update Text for match to current language */
 476         if (ad->navi_it)
 477                 elm_object_item_text_set(ad->navi_it,
 478                                                         dgettext("sys_string", "IDS_COM_BODY_SEARCH"));
 479
 480         if (ad->search_bar)
 481                 elm_object_part_text_set(ad->search_bar,
 482                                                         "elm.guidetext",
 483                                                         dgettext("sys_string", "IDS_COM_BODY_SEARCH"));
 484         if (ad->noresult_view)
 485                 elm_object_part_text_set(ad->noresult_view,
 486                                                         "elm.text",
 487                                                         dgettext("sys_string", "IDS_COM_BODY_NO_SEARCH_RESULTS"));
 488
 489         if (ad->search_cancel_btn)
 490                 elm_object_text_set(ad->search_cancel_btn,
 491                                                         dgettext("sys_string",
 492                                                         "IDS_COM_SK_CANCEL"));
 493
 494         for (i = 0; i < SEARCH_CONT_MAX; i++) {
 495                 Elm_Object_Item *it = ad->result_obj[i].gl_result_grp;
 496                 const char *item_name = ad->result_obj[i].name;
 497
 498                 if (it && item_name)
 499                         elm_genlist_item_fields_update(it, "elm.text", ELM_GENLIST_ITEM_FIELD_TEXT);
 500         }
 501
 502         SEARCH_FUNC_END;
 503 }
 504
 505 static bool __search_app_create(void *data)
 506 {
 507         SEARCH_FUNC_START;
 508
 509         struct appdata *ad = (struct appdata *)data;
 510
 511         ad->win_main = __search_create_win(SEARCH_PACKAGE);
 512
 513         SEARCH_RETV_IF(ad->win_main == NULL, -1);
 514
 515         evas_object_show(ad->win_main);
 516
 517         ad->scale_factor = elm_config_scale_get();
 518
 519         __search_init_category_object(ad);
 520         __search_init_smartsearch(ad);
 521         search_result_gl_init(ad);
 522         search_util_date_time_format_init(NULL);
 523
 524         ad->idler_create_ui = ecore_idler_add(__search_init_after_ui_create, ad);
 525
 526         SEARCH_FUNC_END;
 527
 528         return true;
 529 }
 530
 531 static void __search_app_terminate(void *data)
 532 {
 533         SEARCH_FUNC_START;
 534
 535         struct appdata *ad = (struct appdata *)data;
 536         int i = 0;
 537
 538         if (ad->layout_main) {
 539                 evas_object_del(ad->layout_main);
 540                 ad->layout_main = NULL;
 541         }
 542
 543         if (ad->win_main) {
 544                 evas_object_del(ad->win_main);
 545                 ad->win_main = NULL;
 546         }
 547
 548         if(ad->idler_create_ui)
 549                 ecore_idler_del(ad->idler_create_ui);
 550
 551         if(ad->idler_search)
 552                 ecore_idler_del(ad->idler_search);
 553
 554         search_result_gl_deinit(ad);
 555
 556         search_app_disconnect(ad);
 557         __search_deinit_db_connect(ad);
 558
 559         search_util_date_time_format_deinit();
 560
 561         for ( i = 0 ; i < SEARCH_CONT_MAX ; ++i ) {
 562                 SEARCH_FREE(ad->result_obj[i].name);
 563                 SEARCH_FREE(ad->result_obj[i].obj_icon_path);
 564                 SEARCH_FREE(ad->result_obj[i].def_pkg_name);
 565         }
 566
 567         for ( i = 0 ; i < SEARCH_CATE_MAX ; ++i ) {
 568                 SEARCH_FREE(ad->category_info[i].btn_icon_path);
 569                 SEARCH_FREE(ad->category_info[i].btn_icon_press_path);
 570         }
 571
 572         SEARCH_FREE(ad->search_word);
 573         SEARCH_FREE(ad->not_markup_search_word);
 574
 575         SEARCH_FUNC_END;
 576 }
 577
 578 static void __search_app_pause(void *data)
 579 {
 580         SEARCH_FUNC_START;
 581
 582         SEARCH_FUNC_END;
 583 }
 584
 585 static void __search_app_resume(void *data)
 586 {
 587         SEARCH_FUNC_START;
 588
 589         struct appdata *ad = (struct appdata *)data;
 590
 591         if (ad->win_main) {
 592                 elm_object_focus_set(ad->back_btn, EINA_FALSE);
 593         }
 594         SEARCH_FUNC_END;
 595 }
 596
 597 static void __search_app_service(service_h service, void *data)
 598 {
 599         SEARCH_FUNC_START;
 600
 601         struct appdata *ad = (struct appdata *)data;
 602
 603         char *query = NULL;
 604         char *keyword = NULL;
 605         char *operation = NULL;
 606
 607         Evas_Object *cate_icon;
 608         int ret = 0;
 609         char *icon_path = NULL;
 610
 611         ad->back_btn_type = BACK_BTN_TYPE_LOWER;
 612         SEARCH_FREE(ad->search_word);
 613
 614         ret = service_get_operation(service, &operation);
 615
 616         if (ret != 0) {
 617                 SEARCH_DEBUG_WARNING("Cannot get operation!");
 618                 return;
 619         }
 620
 621         if(operation == NULL ) {
 622                 SEARCH_DEBUG_WARNING("Operation is NULL!");
 623                 return;
 624                         }
 625
 626         SEARCH_DEBUG_LOG("SERVICE OPERATION TYPE : %s", operation);
 627         if (SEARCH_STRCMP(operation, SERVICE_OPERATION_SEARCH) == 0) {
 628                 ret = service_get_extra_data(service, "http://tizen.org/appcontrol/data/keyword", &query);
 629
 630                 if(ret != 0) {
 631                         SEARCH_DEBUG_WARNING("Fail to Get Keyword data!");
 632                         query = NULL;
 633                         }
 634
 635                 if( (query) && (strlen(query) > 0) ) {
 636                         keyword = (char*)malloc(strlen(query)+1);
 637                         memset(keyword, 0x00, strlen(query)+1);
 638                         strncpy(keyword, query, strlen(query));
 639                 }
 640
 641                 ad->search_category = SEARCH_CATE_PHONE;
 642                 ad->back_btn_type = BACK_BTN_TYPE_CLOSE;
 643
 644         } else {
 645                 /* If Operation type is not SEARCH, Initializae valute to default */
 646                         keyword = vconf_get_str(SMARTSEARCH_KEY_KEYWORD);
 647
 648                 if (keyword == NULL)
 649                         SEARCH_DEBUG_WARNING("Error(%d) : get current key from vconf", ret);
 650
 651                 ad->search_category = SEARCH_CATE_PHONE;
 652         }
 653
 654         SEARCH_DEBUG_LOG("current category : %d", ad->search_category);
 655
 656         icon_path = ad->category_info[ad->search_category].btn_icon_path;
 657         cate_icon = search_searchbar_category_icon_add(icon_path,
 658                 ad->sb_layout,
 659                 SEARCH_CATEGORY_BTN_ICON_SIZE_WIDTH,
 660                 SEARCH_CATEGORY_BTN_ICON_SIZE_HEIGHT,
 661                 false);
 662         elm_object_content_set(ad->cate_btn, cate_icon);
 663
 664         /* set current category to vconf */
 665         ad->search_category = SEARCH_CATE_PHONE;
 666
 667         if ((keyword) && (strlen(keyword) > 0)) {
 668                 elm_object_text_set(ad->search_entry, keyword);
 669         } else {
 670                 SEARCH_DEBUG_LOG("keyword is NULL");
 671
 672                 elm_object_text_set(ad->search_entry, "");
 673                 elm_object_signal_emit(ad->search_bar, "cancel,hide", "");
 674
 675                 search_set_result_list(ad);
 676
 677                 /* set focus to entry for launching ime */
 678                 evas_object_show(ad->search_entry);
 679                 elm_object_focus_set(ad->search_entry,EINA_TRUE);
 680                 elm_object_signal_emit(ad->search_bar, "cancel,in", "");
 681         }
 682
 683         SEARCH_FREE(keyword);
 684         SEARCH_FREE(operation);
 685         SEARCH_FREE(query);
 686
 687         elm_entry_cursor_end_set(ad->search_entry);
 688
 689         if (ad->win_main)
 690                 elm_win_activate(ad->win_main);
 691
 692         SEARCH_FUNC_END;
 693 }
 694
 695 static void __search_app_lang_change(void *data)
 696 {
 697         SEARCH_FUNC_START;
 698         struct appdata *ad = (struct appdata *)data;
 699
 700         __search_update_lang(ad);
 701
 702         SEARCH_FUNC_END;
 703 }
 704
 705 int main(int argc, char *argv[])
 706 {
 707         SEARCH_FUNC_START;
 708
 709         struct appdata ad;
 710
 711         int i = 0;
 712
 713         app_event_callback_s event_callback;
 714
 715         event_callback.create = __search_app_create;
 716         event_callback.terminate = __search_app_terminate;
 717         event_callback.pause = __search_app_pause;
 718         event_callback.resume = __search_app_resume;
 719         event_callback.service = __search_app_service;
 720         event_callback.low_memory = NULL;
 721         event_callback.low_battery = NULL;
 722         event_callback.device_orientation = NULL;
 723         event_callback.language_changed = __search_app_lang_change;
 724         event_callback.region_format_changed = search_util_date_time_format_init;
 725
 726         memset(&ad, 0x0, sizeof(struct appdata));
 727
 728         for (i = 0; i < argc; i++)
 729                 SEARCH_DEBUG_LOG("argv[%d] = [%s]\n", i, argv[i]);
 730
 731         SEARCH_FUNC_END;
 732
 733         return app_efl_main(&argc, &argv, &event_callback, &ad);
 734 }