lib/common/ph-common.c

   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://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 #include <app.h>
  19 #include <fcntl.h>
  20 #include <ui-gadget-module.h>
  21 #include <account-types.h>
  22 #include <syspopup_caller.h>
  23 #include <account.h>
  24 #include <notification.h>
  25
  26 #include "phone.h"
  27 #include "phone-common.h"
  28
  29
  30 #define CT_CBAR_ITEM_MAX 4
  31
  32 #ifdef PH_TIMECHECK
  33 double ph_set_start_time(void)
  34 {
  35         struct timeval tv;
  36         double curtime;
  37
  38         gettimeofday(&tv, NULL);
  39         curtime = tv.tv_sec * 1000 + (double)tv.tv_usec/1000;
  40         return curtime;
  41 }
  42
  43 double ph_exec_time(double start)
  44 {
  45         double end = ph_set_start_time();
  46         return (end - start - ph_correction);
  47 }
  48
  49 int ph_init_time(void)
  50 {
  51         double temp_t;
  52         temp_t = ph_set_start_time();
  53         ph_correction = ph_exec_time(temp_t);
  54
  55         return 0;
  56 }
  57 #endif
  58
  59 static void progress_popup_cancel_cb(void *data, Evas_Object *obj, void *event_info)
  60 {
  61         bool *is_alive = data;
  62         *is_alive = false;
  63 }
  64
  65 void phone_free_contacts(Eina_List *list)
  66 {
  67         Eina_List *l;
  68         ph_contact_d *cd;
  69
  70         p_retm_if(NULL == list, "list is NULL");
  71
  72         EINA_LIST_FOREACH(list, l, cd) {
  73                 if (NULL == cd)
  74                         continue;
  75
  76                 free(cd->display);
  77                 free(cd->img_path);
  78                 free(cd->number);
  79                 free(cd);
  80         }
  81         eina_list_free(list);
  82 }
  83
  84 void ctui_list_edit_navi_pop(void *data, Evas_Object *obj, void *event_info)
  85 {
  86         int cnt_checked;
  87         int person_count = 0;
  88         int number_count = 0;
  89         int email_count = 0;
  90         int *result_list_number = NULL;
  91         int *result_list_email = NULL;
  92         int *result_list_person = NULL;
  93         Eina_List *l;
  94         ct_person_list *person_info;
  95         ct_list_data *clist_d = data;
  96
  97         cnt_checked = ctui_list_checked_cnt_get(clist_d->list);
  98
  99         PH_DBG("clist_d->ug_request %d count %d", clist_d->ug_request, cnt_checked);
 100         if (CT_UG_REQUEST_CHECK_FOR_NUMBER == clist_d->ug_request)
 101                 result_list_number = calloc(cnt_checked, sizeof(int));
 102         else if (CT_UG_REQUEST_CHECK_FOR_EMAIL == clist_d->ug_request)
 103                 result_list_email = calloc(cnt_checked, sizeof(int));
 104         else if (CT_UG_REQUEST_CHECK_FOR_NUMBER_OR_EMAIL == clist_d->ug_request) {
 105                 result_list_number = calloc(cnt_checked, sizeof(int));
 106                 result_list_email = calloc(cnt_checked, sizeof(int));
 107         }
 108         else
 109                 result_list_person = calloc(cnt_checked, sizeof(int));
 110
 111
 112         EINA_LIST_FOREACH(clist_d->list, l, person_info) {
 113                 if (NULL == person_info || !person_info->checked) continue;
 114                 if (1 == person_info->id_ret_type)
 115                         result_list_number[number_count++] = person_info->id_ret;
 116                 else if (2 == person_info->id_ret_type)
 117                         result_list_email[email_count++] = person_info->id_ret;
 118                 else
 119                         result_list_person[person_count++] = person_info->id;
 120         }
 121
 122         // setting - import,export / group-view - message,email,chaton,calendar
 123         if (clist_d->select_result_cb) { // called by setting view - check person_info
 124                 if (0 < cnt_checked) {
 125                         if (result_list_number)
 126                                 clist_d->select_result_cb(clist_d->select_result_cb_data, result_list_number, number_count);
 127                         else if (result_list_email)
 128                                 clist_d->select_result_cb(clist_d->select_result_cb_data, result_list_email, email_count);
 129                         else
 130                                 clist_d->select_result_cb(clist_d->select_result_cb_data, result_list_person, person_count);
 131                 }
 132         }
 133         if(result_list_person)
 134                 free(result_list_person);
 135         if(result_list_number)
 136                 free(result_list_number);
 137         if(result_list_email)
 138                 free(result_list_email);
 139 }
 140
 141 void phone_view_back_btn_cb(void *data, Evas_Object *obj, void *event_info)
 142 {
 143         /* TODO : remove evas_object_smart_callback_del, it will be controlled by WINSET */
 144         evas_object_smart_callback_del(obj, "clicked", phone_view_back_btn_cb);
 145         phone_hide_notify(data);
 146         evas_object_smart_callback_del(data, "transition,finished", ctui_list_edit_navi_pop);
 147         elm_naviframe_item_pop(data);
 148 }
 149
 150 void ug_common_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 151 {
 152         Evas_Object *base;
 153
 154         if (!ug)
 155                 return;
 156
 157         base = ug_get_layout(ug);
 158         if (!base) {
 159                 ERR("ug_get_layout() return NULL");
 160                 ug_destroy(ug);
 161                 return;
 162         }
 163         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 164         evas_object_show(base);
 165 }
 166
 167 void ug_common_destroy_cb(ui_gadget_h ug, void *priv)
 168 {
 169         struct ug_priv_data *priv_data;
 170
 171         p_retm_if(NULL == ug, "ug is NULL");
 172         ug_destroy(ug);
 173
 174         p_retm_if(NULL == priv, "priv is NULL");
 175
 176         priv_data = (struct ug_priv_data *)priv;
 177
 178         if (priv_data->destroy_cb)
 179                 priv_data->destroy_cb(priv_data->cb_param);
 180
 181         free(priv);
 182
 183         PH_FN_END;
 184 }
 185
 186 void * phone_image_crop_ug(ui_gadget_h parent, const char *photo,
 187                 struct ug_cbs *cbs)
 188 {
 189         ui_gadget_h ug;
 190
 191         service_h service;
 192
 193         service_create(&service);
 194         service_add_extra_data(service, "Path", photo);
 195         service_add_extra_data(service, "View Mode", "SETAS");
 196         service_add_extra_data(service, "Setas type", "CallerID");
 197         service_add_extra_data(service, "Area Size", "100");
 198
 199         cbs->layout_cb = ug_common_layout_cb;
 200
 201         ug = ug_create(parent, IMG_VIEWER_UG, UG_MODE_FULLVIEW, service, cbs);
 202         p_warn_if(NULL == ug, "ug_create() Failed");
 203
 204         service_destroy(service);
 205
 206         return ug;
 207 }
 208
 209 void* phone_launch_msg_composer_ug(void *parent_ug, char *number, int msg_id,
 210                 void(*destroy_cb)(void*), void *cb_param)
 211 {
 212         PH_FN_CALL;
 213         ui_gadget_h ug;
 214         struct ug_cbs cbs = {0};
 215         struct ug_priv_data *priv_data;
 216         service_h service;
 217         char ret[PH_TEXT_MAX_LEN] = {0};
 218
 219         priv_data = calloc(1, sizeof(struct ug_priv_data));
 220         p_retvm_if(NULL == priv_data, NULL, "calloc is failed");
 221         priv_data->destroy_cb = destroy_cb;
 222         priv_data->cb_param = cb_param;
 223
 224         service_create(&service);
 225         if (number && *number)
 226                 service_add_extra_data(service, "TO", (char*)number);
 227         else if (msg_id) {
 228                 service_add_extra_data(service, "type", "msg_id");
 229                 snprintf(ret, sizeof(ret), "%d", msg_id);
 230                 service_add_extra_data(service, "msgId", ret);
 231         }
 232
 233         cbs.priv = priv_data;
 234         cbs.layout_cb = ug_common_layout_cb;
 235         cbs.result_cb = NULL;
 236         cbs.destroy_cb = ug_common_destroy_cb;
 237
 238         ug = ug_create(parent_ug, MSG_COMPOSER_UG, UG_MODE_FULLVIEW, service, &cbs);
 239         service_destroy(service);
 240
 241         if (ug == NULL) {
 242                 free(priv_data);
 243                 ERR("%s ug_create is failed", MSG_COMPOSER_UG);
 244         }
 245         return ug;
 246 }
 247
 248 void* phone_launch_contact_detail_ug(void *parent_ug, int contact_index,
 249                 void(*destroy_cb)(void*), void *cb_param)
 250 {
 251         PH_FN_CALL;
 252         char buf[PH_TEXT_MAX_LEN] = {0};
 253         struct ug_cbs cbs = {0};
 254         service_h service;
 255         ui_gadget_h ug;
 256         struct ug_priv_data *priv_data;
 257
 258         priv_data = calloc(1, sizeof(struct ug_priv_data));
 259         p_retvm_if(NULL == priv_data, NULL, "calloc is failed");
 260         priv_data->destroy_cb = destroy_cb;
 261         priv_data->cb_param = cb_param;
 262
 263         service_create(&service);
 264
 265         snprintf(buf, sizeof(buf), "%d", contact_index);
 266         service_add_extra_data(service, CT_UG_BUNDLE_ID, buf);
 267         snprintf(buf, sizeof(buf), "%d", CT_UG_REQUEST_DETAIL);
 268         service_add_extra_data(service, CT_UG_BUNDLE_TYPE, buf);
 269
 270         cbs.priv = priv_data;
 271         cbs.layout_cb = ug_common_layout_cb;
 272         cbs.result_cb = NULL;
 273         cbs.destroy_cb = ug_common_destroy_cb;
 274
 275         ug = ug_create(parent_ug, UG_CONTACTS_DETAILS, UG_MODE_FULLVIEW, service, &cbs);
 276         service_destroy(service);
 277
 278         if (NULL == ug) {
 279                 free(priv_data);
 280                 ERR("%s ug_create fail", UG_CONTACTS_DETAILS);
 281         }
 282         return ug;
 283 }
 284
 285 void* phone_launch_contact_add_list_edit_ug(void *parent_ug, char *data,
 286                 void (*destroy_cb)(void *), void *cb_param)
 287 {
 288         PH_FN_END;
 289         char buf[PH_TEXT_MAX_LEN] = {0};
 290         struct ug_cbs cbs = {0};
 291         struct ug_priv_data *priv_data;
 292         ui_gadget_h ug;
 293         service_h service;
 294
 295         priv_data = calloc(1, sizeof(struct ug_priv_data));
 296         p_retvm_if(NULL == priv_data, NULL, "calloc is failed");
 297         priv_data->destroy_cb = destroy_cb;
 298         priv_data->cb_param = cb_param;
 299
 300         service_create(&service);
 301
 302         snprintf(buf, sizeof(buf), "%d", CT_UG_REQUEST_UPDATE_WITH_NUM);
 303         service_add_extra_data(service, CT_UG_BUNDLE_TYPE, buf);
 304         snprintf(buf, sizeof(buf), "%s", data);
 305         service_add_extra_data(service, CT_UG_BUNDLE_NUM, buf);
 306         PH_DBG("number %s", buf);
 307
 308         cbs.priv = priv_data;
 309         cbs.layout_cb = ug_common_layout_cb;
 310         cbs.result_cb = NULL;
 311         cbs.destroy_cb = ug_common_destroy_cb;
 312
 313         ug = ug_create(parent_ug, UG_CONTACTS_LIST, UG_MODE_FULLVIEW, service, &cbs);
 314         service_destroy(service);
 315         if (NULL == ug) {
 316                 free(priv_data);
 317                 ERR("%s ug_create fail", UG_CONTACTS_LIST);
 318         }
 319         return ug;
 320 }
 321
 322 static void ug_contact_list_result_cb(ui_gadget_h ug, service_h service, void *priv)
 323 {
 324         PH_FN_CALL;
 325         char *temp_p = NULL;
 326         struct ug_priv_data *priv_data = priv;
 327         int id;
 328         p_retm_if(NULL == priv, "private data is NULL");
 329
 330         service_get_extra_data(service, "id", &temp_p);
 331         id = atoi(temp_p);
 332         free(temp_p);
 333         if (priv_data->result_cb)
 334                 priv_data->result_cb(priv_data->cb_param, (void*)&id);
 335         PH_FN_END;
 336 }
 337
 338 void* phone_launch_contact_list_ug(void *parent_ug, int request,
 339                 void(*result_cb)(void*, void*), void(*destroy_cb)(void*), void*cb_param)
 340 {
 341         PH_FN_CALL;
 342         char ug_request[PH_TEXT_MAX_LEN] = {0};
 343         struct ug_priv_data *priv_data;
 344         ui_gadget_h ug;
 345         struct ug_cbs cbs = {0};
 346         service_h service;
 347
 348         priv_data = calloc(1, sizeof(struct ug_priv_data));
 349         p_retvm_if(NULL == priv_data, NULL, "calloc is failed");
 350         priv_data->destroy_cb = destroy_cb;
 351         priv_data->result_cb = result_cb;
 352         priv_data->cb_param = cb_param;
 353
 354         service_create(&service);
 355
 356         snprintf(ug_request, sizeof(ug_request), "%d", request);
 357         service_add_extra_data(service, CT_UG_BUNDLE_TYPE, ug_request);
 358
 359         cbs.priv = priv_data;
 360         cbs.layout_cb = ug_common_layout_cb;
 361         cbs.destroy_cb = ug_common_destroy_cb;
 362         cbs.result_cb = ug_contact_list_result_cb;
 363
 364         ug = ug_create(parent_ug, UG_CONTACTS_LIST, UG_MODE_FULLVIEW, service, &cbs);
 365         service_destroy(service);
 366         if (NULL == ug) {
 367                 free(priv_data);
 368                 ERR("%s ug_create fail", UG_CONTACTS_LIST);
 369         }
 370         return ug;
 371 }
 372
 373 Evas_Object* phone_create_list_sweep_btn(Evas_Object *parent, char *fullpath)
 374 {
 375         Evas_Object *btn;
 376         Evas_Object *icon;
 377
 378         btn = elm_button_add(parent);
 379         p_retvm_if(NULL == btn, NULL, "elm_button_add() return NULL");
 380
 381         icon = elm_icon_add(btn);
 382         p_retvm_if(NULL == icon, NULL, "phone_create_icon_with_img() return NULL");
 383
 384         elm_icon_file_set(icon, fullpath, NULL);
 385         elm_icon_resizable_set(icon, EINA_FALSE, EINA_FALSE);
 386         elm_object_part_content_set(btn, "icon", icon);
 387
 388         return btn;
 389 }
 390
 391 void phone_resize_notify(Evas_Object *parent, int rotate)
 392 {
 393         Evas_Object *notify;
 394         Evas_Object *layout;
 395         const char *msg;
 396         p_retm_if(NULL == parent, "parent is NULL");
 397         notify = phone_get_notify(parent);
 398         layout = elm_object_content_get(notify);
 399         msg = edje_object_part_text_get(_EDJ(layout), "elm.text");
 400
 401         elm_layout_theme_set(layout, "standard", "selectioninfo", "center_text");
 402
 403         if (msg && *msg)
 404                 edje_object_part_text_set(_EDJ(layout), "elm.text", msg);
 405 }
 406
 407 Evas_Object * phone_get_notify(Evas_Object *parent)
 408 {
 409         Evas_Object *notify;
 410
 411         notify = evas_object_data_get(parent, "notify");
 412         if (NULL == notify) {
 413                 Evas_Object *info_layout;
 414                 notify = phone_create_base_layout(parent, false);
 415                 elm_object_part_content_set(parent, "selectioninfo", notify);
 416                 info_layout = elm_layout_add(parent);
 417                 elm_object_part_content_set(notify, "elm.swallow.content", info_layout);
 418                 elm_layout_theme_set(info_layout, "standard", "selectioninfo", "center_text");
 419                 evas_object_data_set(parent, "notify", notify);
 420         }
 421         evas_object_show(notify);
 422         return notify;
 423 }
 424
 425 void phone_show_tickernoti(const char *msg)
 426 {
 427         int err = notification_status_message_post(msg);
 428         p_retm_if(NOTIFICATION_ERROR_NONE != err, "notification_status_message_post is failed");
 429 }
 430
 431 void phone_show_notify(Evas_Object *parent, const char *msg)
 432 {
 433         Evas_Object *selectioninfo;
 434         Evas_Object *notify;
 435
 436         notify = phone_get_notify(parent);
 437         selectioninfo = elm_object_part_content_get(notify, "elm.swallow.content");
 438         elm_object_part_text_set(selectioninfo, "elm.text", msg);
 439         elm_object_signal_emit(parent, "show,selection,info", "elm");
 440         evas_object_show(selectioninfo);
 441 }
 442
 443 void phone_hide_notify(Evas_Object *parent)
 444 {
 445         Evas_Object *selectioninfo;
 446         Evas_Object *notify;
 447
 448         notify = evas_object_data_get(parent, "notify");
 449         selectioninfo = elm_object_part_content_get(notify, "elm.swallow.content");
 450         elm_object_signal_emit(parent, "hide,selection,info", "elm");
 451         evas_object_hide(notify);
 452         evas_object_hide(selectioninfo);
 453 }
 454
 455 static void popup_cancel_btn_cb(void *data, Evas_Object *obj, void *event_info)
 456 {
 457         Evas_Object **popup = data;
 458         evas_object_del(*popup);
 459         *popup = NULL;
 460 }
 461
 462 void ctui_popup_hide_cb(void *data, Evas_Object *obj, void *event_info)
 463 {
 464         evas_object_del(data);
 465 }
 466
 467 Evas_Object *phone_show_popup(Evas_Object *parent, const char *desc, double timeout)
 468 {
 469         Evas_Object *popup;
 470
 471         popup = evas_object_data_get(parent, "popup");
 472         if (NULL == popup) {
 473                 popup = elm_popup_add(parent);
 474                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 475                 evas_object_smart_callback_add(popup, "block,clicked", ctui_popup_hide_cb, NULL);
 476                 evas_object_show(popup);
 477         }
 478         elm_object_text_set(popup, desc);
 479         elm_popup_timeout_set(popup, timeout);
 480         return popup;
 481 }
 482
 483 Evas_Object* phone_create_confirm_popup(Evas_Object **popup, Evas_Object *win, const char* description,
 484                 void (*btn_clicked_cb)(void *, Evas_Object *, void *), void *cb_data)
 485 {
 486         Evas_Object *btn1, *btn2;
 487         *popup = elm_popup_add(win);
 488         evas_object_size_hint_weight_set(*popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 489         elm_object_text_set(*popup, description);
 490
 491         btn1 = elm_button_add(*popup);
 492         elm_object_text_set(btn1, S_(PH_SYS_SK_YES));
 493         elm_object_part_content_set(*popup, "button1", btn1);
 494         elm_object_style_set(btn1, "popup_button/default");
 495         evas_object_smart_callback_add(btn1, "clicked", btn_clicked_cb, cb_data);
 496
 497         btn2 = elm_button_add(*popup);
 498         elm_object_text_set(btn2, S_(PH_SYS_SK_NO));
 499         elm_object_part_content_set(*popup, "button2", btn2);
 500         elm_object_style_set(btn2, "popup_button/default");
 501         evas_object_smart_callback_add(btn2, "clicked", popup_cancel_btn_cb, &(*popup));
 502
 503         evas_object_show(*popup);
 504
 505         return btn1;
 506 }
 507
 508 void phone_launch_voice_call(const int person_id, const char* number)
 509 {
 510         char buf[PH_TEXT_MAX_LEN] = {0};
 511         service_h service;
 512         int ret;
 513
 514         ret = service_create(&service);
 515         p_retm_if(SERVICE_ERROR_NONE != ret, "service_create() Failed(%d)", ret);
 516
 517         service_set_operation(service, SERVICE_OPERATION_CALL);
 518         snprintf(buf, sizeof(buf), "tel:%s", number);
 519         service_set_uri(service, buf);
 520
 521         if (0 < person_id) {
 522                 char buf[PH_TEXT_MAX_LEN] = {0};
 523                 snprintf(buf, sizeof(buf), "%d", person_id);
 524                 service_add_extra_data(service, "ctindex", buf);
 525
 526         }
 527         service_send_launch_request(service, NULL, NULL);
 528         service_destroy(service);
 529 }
 530
 531 Evas_Object* phone_create_base_layout(Evas_Object *parent, bool is_fullview)
 532 {
 533         Evas_Object *base;
 534
 535         base = elm_layout_add(parent);
 536         p_retvm_if(NULL == base, NULL, "elm_layout_add() Failed");
 537         if (is_fullview)
 538                 elm_layout_theme_set(base, "layout", "application", "default");
 539         else
 540                 elm_layout_theme_set(base, "layout", "application", "noindicator");
 541         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 542
 543         return base;
 544 }
 545
 546 void phone_ug_destroy_me_cb(void *data, Evas_Object *obj, void *event_info)
 547 {
 548         PH_FN_CALL;
 549         if(data)
 550                 ug_destroy_me(data);
 551         PH_FN_END;
 552 }
 553
 554 void phone_back_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 555 {
 556         Evas_Object *win = data;
 557         elm_win_lower(win);
 558 }
 559
 560 Evas_Object* phone_create_bg(Evas_Object *parent)
 561 {
 562         Evas_Object *bg;
 563
 564         bg = elm_bg_add(parent);
 565         p_retvm_if(NULL == bg, NULL, "elm_bg_add() return NULL");
 566
 567         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 568         elm_object_part_content_set(parent, "elm.swallow.bg", bg);
 569
 570         return bg;
 571 }
 572
 573 Evas_Object* phone_progressbar_popup(Evas_Object *parent, ph_progress_info *p_info, const char *title)
 574 {
 575         char buf[PH_TEXT_MAX_LEN];
 576         Evas_Object *popup;
 577         Evas_Object *layout;
 578         Evas_Object *label;
 579         Evas_Object *progressbar;
 580         Evas_Object *btn;
 581
 582         popup = elm_popup_add(parent);
 583         p_retvm_if(NULL == popup, NULL, "elm_popup_add() return NULL");
 584
 585         layout = elm_layout_add(popup);
 586         p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL");
 587         elm_layout_file_set(layout, PROGRESS_EDJ, "popup_center_text_progressview");
 588         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 589         p_info->layout = layout;
 590
 591         label = elm_label_add(popup);
 592         p_retvm_if(NULL == label, NULL, "elm_label_add() return NULL");
 593         elm_object_style_set(label, "popup/progressview");
 594         elm_label_line_wrap_set(label, ELM_WRAP_WORD);
 595         elm_object_text_set(label, title);
 596         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 597         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 598         evas_object_show(label);
 599
 600         progressbar = elm_progressbar_add(popup);
 601         p_retvm_if(NULL == progressbar, NULL, "elm_progressbar_add() return NULL");
 602         p_info->progressbar= progressbar;
 603
 604         if (0 < p_info->cnt_checked_total) {
 605                 elm_object_style_set(progressbar, "list_progress");
 606                 elm_progressbar_value_set(progressbar, 0.0);
 607         }
 608         else {
 609                 elm_object_style_set(progressbar, "pending_list");
 610                 elm_progressbar_pulse(progressbar, EINA_TRUE);
 611         }
 612
 613         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 614         evas_object_show(progressbar);
 615
 616         elm_progressbar_horizontal_set(progressbar, EINA_TRUE);
 617         elm_object_part_content_set(layout, "elm.swallow.content", label);
 618         elm_object_part_content_set(layout, "elm.swallow.end", progressbar);
 619         evas_object_show(layout);
 620         elm_object_content_set(popup, layout);
 621
 622         if(false == p_info->without_cancel_btn)
 623         {
 624                 btn = elm_button_add(popup);
 625                 elm_object_text_set(btn, S_(PH_SYS_SK_CANCEL));
 626                 elm_object_part_content_set(popup, "button1", btn);
 627                 elm_object_style_set(btn, "popup_button/default");
 628                 evas_object_smart_callback_add(btn, "clicked", progress_popup_cancel_cb, &p_info->alive);
 629         }
 630         evas_object_show(popup);
 631         return popup;
 632 }
 633
 634 void phone_navi_item_clear(Elm_Object_Item *navi_item)
 635 {
 636         int i = 0;
 637         Evas_Object *toolbar_button = NULL;
 638         const char* toolbar_button_name[] = {
 639                 "toolbar_button1",
 640                 "toolbar_button2",
 641                 "toolbar_more_btn",
 642                 "title_left_btn",
 643                 "title_right_btn",
 644                 "prev_btn",
 645         };
 646
 647         for (i=0;i<sizeof(toolbar_button_name)/sizeof(char*);i++) {
 648                 toolbar_button = elm_object_item_part_content_unset(navi_item, toolbar_button_name[i]);
 649                 if (toolbar_button)
 650                         evas_object_del(toolbar_button);
 651         }
 652 }
 653
 654 Evas_Object *phone_create_icon_with_img(Evas_Object *parent, char *full_path)
 655 {
 656         Evas_Object *ic = elm_icon_add(parent);
 657         p_retvm_if(NULL == ic, NULL, "elm_icon_add() return NULL");
 658         elm_icon_file_set(ic, full_path, NULL);
 659         elm_icon_resizable_set(ic, EINA_TRUE, EINA_TRUE);
 660         evas_object_image_smooth_scale_set(ic, EINA_FALSE);
 661         return ic;
 662 }
 663
 664
 665 contacts_error_e phone_cts_get_list(const char *view_uri, int property_id, int match_value, contacts_list_h *out_list)
 666 {
 667         contacts_error_e err = CONTACTS_ERROR_NONE;
 668         contacts_filter_h filter = NULL;
 669         contacts_query_h query = NULL;
 670
 671         p_retvm_if(NULL == out_list, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(out_list) is NULL");
 672
 673         unsigned int person_grouprel_projection[] = {
 674                 _contacts_person_grouprel.person_id,
 675                 _contacts_person_grouprel.status,
 676                 _contacts_person_grouprel.display_name,
 677                 _contacts_person_grouprel.display_name_index,
 678                 _contacts_person_grouprel.addressbook_ids,
 679                 _contacts_person_grouprel.image_thumbnail_path,
 680                 _contacts_person_grouprel.link_count,
 681         };
 682
 683         err = contacts_filter_create(view_uri, &filter);
 684         p_retvm_if(CONTACTS_ERROR_NONE != err, err, "contactcs_filter_create() Failed(%d)", err);
 685
 686         do {
 687                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_int(filter, property_id, CONTACTS_MATCH_EQUAL, match_value))) break;
 688                 if (CONTACTS_ERROR_NONE != (err = contacts_query_create(view_uri, &query))) break;
 689                 if (CONTACTS_ERROR_NONE != (err = contacts_query_set_filter(query, filter))) break;
 690
 691                 if (0 == strcmp(view_uri, _contacts_person_grouprel._uri)) {
 692                         if (CONTACTS_ERROR_NONE != (err = contacts_query_set_distinct(query, true))) break;
 693                         if (CONTACTS_ERROR_NONE != (err = contacts_query_set_projection(query, person_grouprel_projection, sizeof(person_grouprel_projection)/sizeof(int)))) break;
 694                 }
 695
 696                 if (CONTACTS_ERROR_NONE != (err = contacts_db_get_records_with_query(query, 0, 0, out_list))) break;
 697
 698                 contacts_filter_destroy(filter);
 699                 contacts_query_destroy(query);
 700
 701                 return CONTACTS_ERROR_NONE;
 702         } while (0);
 703         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_create() Failed(%d)", err);
 704
 705         contacts_filter_destroy(filter);
 706         contacts_query_destroy(query);
 707
 708         return err;
 709 }
 710
 711 void phone_cts_free_list(contacts_list_h list)
 712 {
 713         contacts_error_e err = CONTACTS_ERROR_NONE;
 714         err = contacts_list_destroy(list, true);
 715         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_destroy() Failed(%d)", err);
 716 }
 717
 718 contacts_error_e phone_cts_get_int_from_list(contacts_list_h list, int property_id, int *out_int)
 719 {
 720         contacts_error_e err = CONTACTS_ERROR_NONE;
 721         contacts_record_h record = NULL;
 722
 723         p_retvm_if(NULL == out_int, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(out_int) is NULL");
 724         p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(list) is NULL");
 725
 726         err = contacts_list_get_current_record_p(list, &record);
 727         if (CONTACTS_ERROR_NONE != err) {
 728                 ERR("contacts_list_get_current_record_p() Failed(%d)", err);
 729                 return err;
 730         }
 731
 732         err = contacts_record_get_int(record, property_id, out_int);
 733         if (CONTACTS_ERROR_NONE != err) {
 734                 ERR("contacts_record_get_int() Failed(%d)", err);
 735                 return err;
 736         }
 737
 738         return CONTACTS_ERROR_NONE;
 739 }
 740
 741 contacts_error_e phone_cts_get_str_from_list(contacts_list_h list, int property_id, char **out_str)
 742 {
 743         contacts_error_e err = CONTACTS_ERROR_NONE;
 744         contacts_record_h record = NULL;
 745
 746         p_retvm_if(NULL == out_str, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(out_int) is NULL");
 747         p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(list) is NULL");
 748
 749         err = contacts_list_get_current_record_p(list, &record);
 750         if (CONTACTS_ERROR_NONE != err) {
 751                 ERR("contacts_list_get_current_record_p() Failed(%d)", err);
 752                 return err;
 753         }
 754
 755         err = contacts_record_get_str(record, property_id, out_str);
 756         if (CONTACTS_ERROR_NONE != err) {
 757                 ERR("contacts_record_get_str() Failed(%d)", err);
 758                 return err;
 759         }
 760
 761         return CONTACTS_ERROR_NONE;
 762 }
 763
 764 contacts_error_e phone_cts_get_bool_from_list(contacts_list_h list, int property_id, bool *out_bool)
 765 {
 766         contacts_error_e err = CONTACTS_ERROR_NONE;
 767         contacts_record_h record = NULL;
 768
 769         p_retvm_if(NULL == out_bool, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(out_bool) is NULL");
 770         p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(list) is NULL");
 771
 772         err = contacts_list_get_current_record_p(list, &record);
 773         if (CONTACTS_ERROR_NONE != err) {
 774                 ERR("contacts_list_get_current_record_p() Failed(%d)", err);
 775                 return err;
 776         }
 777
 778         err = contacts_record_get_bool(record, property_id, out_bool);
 779         if (CONTACTS_ERROR_NONE != err) {
 780                 ERR("contacts_record_get_bool() Failed(%d)", err);
 781                 return err;
 782         }
 783
 784         return CONTACTS_ERROR_NONE;
 785 }
 786
 787
 788 char* ctui_get_addressbook_icon_path(int addressbook_id)
 789 {
 790         int ret;
 791         int account_id;
 792         char *icon_path;
 793         char *addressbook_name = NULL;
 794         account_h account;
 795         contacts_error_e err = CONTACTS_ERROR_NONE;
 796         contacts_record_h record = NULL;
 797
 798         err = contacts_db_get_record(_contacts_address_book._uri, addressbook_id, &record);
 799         p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "phone_cts_get_list() Failed(%d)", err);
 800
 801         err = contacts_record_get_int(record, _contacts_address_book.account_id, &account_id);
 802         if (CONTACTS_ERROR_NONE != err) {
 803                 ERR("contacts_record_get_int() Failed(%d)", err);
 804                 err = contacts_record_destroy(record, true);
 805                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
 806                 return NULL;
 807         }
 808         err = contacts_record_get_str_p(record, _contacts_address_book.name, &addressbook_name);
 809         if (CONTACTS_ERROR_NONE != err) {
 810                 ERR("contacts_record_get_int() Failed(%d)", err);
 811                 err = contacts_record_destroy(record, true);
 812                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
 813                 return NULL;
 814         }
 815
 816         if (0 == account_id){
 817                         return SAFE_STRDUP(CTUI_IMG_ACC_PHONE);
 818         }
 819
 820
 821         ret = account_connect();
 822         p_retvm_if(ACCOUNT_ERROR_NONE != ret, NULL, "account_connect() Failed(%d)", ret);
 823
 824         account = NULL;
 825         ret = account_create(&account);
 826         p_retvm_if(ACCOUNT_ERROR_NONE != ret, false, "account_create() Failed(%d)", ret);
 827
 828         ret = account_query_account_by_account_id(account_id, &account);
 829         if (ACCOUNT_ERROR_NONE != ret) {
 830                 ERR("account_query_account_by_account_id() Failed(%d)", ret);
 831                 account_destroy(account);
 832                 account_disconnect();
 833                 return NULL;
 834         }
 835         p_retvm_if(ACCOUNT_ERROR_NONE != ret, NULL, "account_query_account_by_account_id() Failed(%d)", ret);
 836
 837         ret = account_get_icon_path(account, &icon_path);
 838         if (ACCOUNT_ERROR_NONE != ret) {
 839                 ERR("account_get_icon_path() Failed(%d)", ret);
 840                 account_destroy(account);
 841                 account_disconnect();
 842                 return NULL;
 843         }
 844         account_destroy(account);
 845         account_disconnect();
 846
 847         return icon_path;
 848 }
 849
 850 Evas_Object* phone_create_navi_btn(Evas_Object *parent, const char *style)
 851 {
 852         Evas_Object *btn;
 853
 854         btn = elm_button_add(parent);
 855         elm_object_style_set(btn, style);
 856         evas_object_show(btn);
 857
 858         return btn;
 859 }
 860
 861 void phone_set_view_info(ph_view_info *view_info, Evas_Object *win, Evas_Object *navi,
 862                 void *ug, int ug_request, int cnt_max, char *ug_data)
 863 {
 864         view_info->win = win;
 865         view_info->navi = navi;
 866         view_info->ug = ug;
 867         view_info->ug_request = ug_request;
 868         view_info->ug_cnt_max = cnt_max;
 869         view_info->ug_data = ug_data;
 870 }
 871
 872 void phone_list_ug_return_ids(ui_gadget_h ug, int *result_list, int cnt, const char *bd_key)
 873 {
 874         gchar *encoded_str;
 875         service_h service;
 876
 877         service_create(&service);
 878
 879         if (result_list) {
 880                 encoded_str = g_base64_encode((guchar *)result_list, cnt*sizeof(int));
 881                 service_add_extra_data(service, bd_key, encoded_str);
 882                 g_free(encoded_str);
 883         }
 884
 885         ug_send_result(ug, service);
 886
 887         service_destroy(service);
 888 }
 889
 890 void phone_list_ug_return_values(service_h service, int *result_list, int cnt, const char *result_type)
 891 {
 892         service_h reply;
 893         int ct_ret;
 894         int i = 0, j = 0;
 895         char **result_array = NULL;
 896         service_result_e result = SERVICE_RESULT_SUCCEEDED;
 897
 898         p_retm_if(result_list == NULL || cnt < 1 || result_type == NULL, "invalid input param");
 899
 900         service_create(&reply);
 901         result_array = calloc(cnt, sizeof(char *));
 902
 903         if(strcmp(CT_OPERATION_RESULT_TYPE_PHONE, result_type) == 0) {
 904                 for (i = 0; i < cnt; i++) {
 905                         contacts_record_h number_record = NULL;
 906                         char *number = NULL;
 907                         ct_ret = contacts_db_get_record(_contacts_number._uri, result_list[i], &number_record);
 908                         if (ct_ret != CONTACTS_ERROR_NONE) {
 909                                 ERR("contacts_db_get_record number failed id %d", result_list[i]);
 910                                 continue;
 911                         }
 912
 913                         contacts_record_get_str_p(number_record, _contacts_number.number, &number);
 914                         result_array[i] = strdup(number);
 915                         PH_DBG("number %s", result_array[i]);
 916                         contacts_record_destroy(number_record, TRUE);
 917                 }
 918
 919                 service_add_extra_data_array(reply, CT_OPERATION_PHONE, (const char **)result_array, cnt);
 920         }
 921         else if(strcmp(CT_OPERATION_RESULT_TYPE_EMAIL, result_type) == 0) {
 922                 for (i = 0; i < cnt; i++) {
 923                         contacts_record_h email_record = NULL;
 924                         char *email = NULL;
 925                         ct_ret = contacts_db_get_record(_contacts_email._uri, result_list[i], &email_record);
 926                         if (ct_ret != CONTACTS_ERROR_NONE) {
 927                                 ERR("contacts_db_get_record email faile id %d", result_list[i]);
 928                                 continue;
 929                         }
 930
 931                         contacts_record_get_str_p(email_record, _contacts_email.email, &email);
 932                         result_array[i] = strdup(email);
 933                         PH_DBG("email %s", result_array[i]);
 934                         contacts_record_destroy(email_record, TRUE);
 935                 }
 936
 937                 service_add_extra_data_array(reply, CT_OPERATION_EMAIL, (const char **)result_array, cnt);
 938
 939         }
 940         else if(strcmp(CT_OPERATION_RESULT_TYPE_ITEM_ID, result_type) == 0) {
 941                 for (i = 0; i < cnt; i++) {
 942                         char buf[4];
 943                         snprintf(buf, sizeof(buf), "%d", result_list[i]);
 944                         result_array[i] = strdup(buf);
 945                         PH_DBG("person id %s", result_array[i]);
 946                 }
 947
 948                 service_add_extra_data_array(reply, CT_OPERATION_ITEM_ID, (const char **)result_array, cnt);
 949
 950         }
 951         else {
 952                 ERR("wrong result type %s", result_type);
 953                 result = SERVICE_RESULT_FAILED;
 954         }
 955
 956         service_reply_to_launch_request(reply, service, result);
 957         service_destroy(reply);
 958
 959         for (j = 0; j < i; j++) {
 960                 free(result_array[j]);
 961         }
 962         free(result_array);
 963 }
 964
 965 void phone_service_reply_simple(service_h service, service_result_e result)
 966 {
 967         service_h reply;
 968         service_create(&reply);
 969         service_reply_to_launch_request(reply, service, result);
 970         service_destroy(reply);
 971 }
 972
 973 void phone_list_ug_return_number_email_ids(ui_gadget_h ug, int *result_number_list, int number_list_count, int *result_email_list, int email_list_count)
 974 {
 975         gchar *encoded_str;
 976         service_h service;
 977         service_create(&service);
 978
 979         if (result_number_list && number_list_count) {
 980                 encoded_str = g_base64_encode((guchar *)result_number_list, number_list_count*sizeof(int));
 981                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_NUMBER_ID_LIST, encoded_str);
 982                 g_free(encoded_str);
 983         }
 984
 985         if (result_email_list && email_list_count) {
 986                 encoded_str = g_base64_encode((guchar *)result_email_list, email_list_count*sizeof(int));
 987                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_EMAIL_ID_LIST, encoded_str);
 988                 g_free(encoded_str);
 989         }
 990
 991         ug_send_result(ug, service);
 992         service_destroy(service);
 993 }
 994
 995
 996 #define CT_UG_BUNDLE_RESULT_ID "id"
 997 #define CT_UG_BUNDLE_RESULT_VCARD "vcard"
 998
 999 void phone_ug_return_id(ui_gadget_h ug, int ct_id, int num_id, int email_id)
1000 {
1001         service_h service;
1002         char buf[16];
1003
1004         service_create(&service);
1005
1006         if (ct_id) {
1007                 snprintf(buf, sizeof(buf), "%d", ct_id);
1008                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf);
1009                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_PERSON_ID, buf);
1010         }
1011
1012         if (num_id) {
1013                 snprintf(buf, sizeof(buf), "%d", num_id);
1014                 service_remove_extra_data(service, CT_UG_BUNDLE_RESULT_ID);
1015                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf);
1016                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_NUMBER_ID, buf);
1017         }
1018
1019         if (email_id) {
1020                 snprintf(buf, sizeof(buf), "%d", email_id);
1021                 service_remove_extra_data(service, CT_UG_BUNDLE_RESULT_ID);
1022                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf);
1023                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_EMAIL_ID, buf);
1024         }
1025
1026         PH_DBG("ct_id =%d, num_id=%d,email_id=%d",ct_id,num_id,email_id);
1027         ug_send_result(ug, service);
1028
1029         service_destroy(service);
1030 }
1031
1032 void phone_ug_return_value(service_h service, int person_id, int num_id, int email_id, int result_id)
1033 {
1034         service_h reply;
1035         char buf[16];
1036         contacts_error_e err = CONTACTS_ERROR_NONE;
1037         contacts_record_h number_record = NULL;
1038         contacts_record_h email_record = NULL;
1039
1040         service_create(&reply);
1041
1042         if (person_id) {
1043                 char **result_array = NULL;
1044                 result_array = calloc(1, sizeof(char *));
1045
1046                 snprintf(buf, sizeof(buf), "%d", person_id);
1047                 PH_DBG("person id %s", buf);
1048
1049                 result_array[0] = strdup(buf);
1050                 service_add_extra_data_array(reply, CT_OPERATION_ITEM_ID, (const char **)result_array, 1);
1051
1052                 service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED);
1053
1054                 service_destroy(reply);
1055
1056                 free(result_array[0]);
1057                 free(result_array);
1058
1059                 return;
1060         }
1061
1062         if (num_id) {
1063                 const char *number = NULL;
1064                 char **result_array = NULL;
1065                 result_array = calloc(1, sizeof(char *));
1066
1067                 err = contacts_db_get_record(_contacts_number._uri, num_id, &number_record);
1068                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_db_get_record() Failed(%d)", err);
1069
1070                 err = contacts_record_get_str_p(number_record, _contacts_number.number, (char**)&number);
1071                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_get_str_p() Failed(%d)", err);
1072
1073                 PH_DBG("number=%d", number);
1074
1075                 result_array[0] = strdup(number);
1076                 service_add_extra_data_array(reply, CT_OPERATION_RESULT_TYPE_PHONE, (const char **)result_array, 1);
1077
1078                 service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED);
1079
1080                 err = contacts_record_destroy(number_record, true);
1081                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1082
1083                 service_destroy(reply);
1084
1085                 free(result_array[0]);
1086                 free(result_array);
1087
1088                 return;
1089         }
1090
1091         if (email_id) {
1092                 const char *email = NULL;
1093                 char **result_array = NULL;
1094                 result_array = calloc(1, sizeof(char *));
1095
1096                 err = contacts_db_get_record(_contacts_email._uri, email_id, &email_record);
1097                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_db_get_record() Failed(%d)", err);
1098
1099                 err = contacts_record_get_str_p(email_record, _contacts_email.email, (char**)&email);
1100                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_get_str_p() Failed(%d)", err);
1101
1102                 PH_DBG("email=%d", email);
1103
1104                 result_array[0] = strdup(email);
1105                 service_add_extra_data_array(reply, CT_OPERATION_RESULT_TYPE_EMAIL, (const char **)result_array, 1);
1106
1107                 service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED);
1108
1109                 err = contacts_record_destroy(email_record, true);
1110                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1111
1112                 service_destroy(reply);
1113
1114                 free(result_array[0]);
1115                 free(result_array);
1116
1117                 return;
1118         }
1119
1120         if (result_id) {
1121                 snprintf(buf, sizeof(buf), "%d", person_id);
1122                 PH_DBG("person id %s", buf);
1123
1124                 service_add_extra_data(reply, CT_OPERATION_ITEM_ID, buf);
1125
1126                 service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED);
1127
1128                 service_destroy(reply);
1129
1130                 return;
1131         }
1132
1133 }
1134
1135 void phone_ug_operation_return_vcard(service_h service, int ct_id, char *vcard)
1136 {
1137         service_h reply;
1138
1139         service_create(&reply);
1140
1141         if (vcard) {
1142                 service_add_extra_data(reply, CT_OPERATION_PATH, vcard);
1143         }
1144
1145         service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED);
1146
1147         service_destroy(reply);
1148 }
1149
1150 void phone_ug_return_vcard(ui_gadget_h ug, int ct_id, char *vcard)
1151 {
1152         service_h service;
1153         char buf[16];
1154
1155         service_create(&service);
1156
1157         if (ct_id) {
1158                 snprintf(buf, sizeof(buf), "%d", ct_id);
1159                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf);
1160         }
1161
1162         if (vcard) {
1163                 service_add_extra_data(service, CT_UG_BUNDLE_RESULT_VCARD, vcard);
1164         }
1165
1166         ug_send_result(ug, service);
1167
1168         service_destroy(service);
1169 }
1170
1171 static void editfield_exceed_string_cb(void *data, Evas_Object *obj, void *event_info)
1172 {
1173         phone_show_tickernoti(T_(CT_GET_TEXT_ERR, CTTEXT_EXCEED_LIMIT));
1174 }
1175
1176 static void editfield_changed_cb(void *data, Evas_Object *obj, void *event_info)
1177 {
1178         if (!elm_entry_is_empty(obj))
1179                 elm_object_signal_emit(data, "elm,state,guidetext,hide", "elm");
1180
1181         if (elm_object_focus_get(data)) {
1182                 if (elm_entry_is_empty(obj))
1183                         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
1184                 else
1185                         elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
1186         }
1187 }
1188 static void editfield_focused_cb(void *data, Evas_Object *obj, void *event_info)
1189 {
1190         if (!elm_entry_is_empty(obj))
1191                 elm_object_signal_emit(data, "elm,state,eraser,show", "elm");
1192         elm_object_signal_emit(data, "elm,state,guidetext,hide", "elm");
1193 }
1194
1195 static void editfield_unfocused_cb(void *data, Evas_Object *obj, void *event_info)
1196 {
1197         if (elm_entry_is_empty(obj))
1198                 elm_object_signal_emit(data, "elm,state,guidetext,show", "elm");
1199         elm_object_signal_emit(data, "elm,state,eraser,hide", "elm");
1200 }
1201
1202 static void editfield_eraser_clicked_cb(void *data, Evas_Object *obj, const char *emission, const char *source)
1203 {
1204         elm_entry_entry_set(data, "");
1205 }
1206
1207 Evas_Object* ctui_create_editfield(Evas_Object *parent, const char *title, const char *guide, bool multiline)
1208 {
1209         Evas_Object *layout, *entry;
1210
1211         layout = elm_layout_add(parent);
1212         if (title && *title) {
1213                 elm_layout_theme_set(layout, "layout", "editfield", "title");
1214                 elm_object_part_text_set(layout, "elm.text", title);
1215         }
1216         else
1217                 elm_layout_theme_set(layout, "layout", "editfield", "default");
1218
1219         if (guide && *guide)
1220                 elm_object_part_text_set(layout, "elm.guidetext", guide);
1221
1222         entry = elm_entry_add(parent);
1223         if (!multiline) {
1224                 elm_entry_scrollable_set(entry, EINA_TRUE);
1225                 elm_entry_single_line_set(entry, EINA_TRUE);
1226         }
1227         ctui_entry_limit_size_set(entry);
1228         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
1229         elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NORMAL);
1230         evas_object_smart_callback_add(entry, "changed", editfield_changed_cb, layout);
1231         evas_object_smart_callback_add(entry, "preedit,changed", editfield_changed_cb, layout);
1232         evas_object_smart_callback_add(entry, "focused", editfield_focused_cb, layout);
1233         evas_object_smart_callback_add(entry, "unfocused", editfield_unfocused_cb, layout);
1234         evas_object_smart_callback_add(entry, "maxlength,reached", editfield_exceed_string_cb, layout);
1235         elm_object_part_content_set(layout, "elm.swallow.content", entry);
1236         elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm", editfield_eraser_clicked_cb, entry);
1237         return layout;
1238 }
1239
1240 // This function is used in Contact view, Group view
1241 void* ctui_account_ug(void *data, Evas_Object *obj, void *event_info,
1242                 void(*destroy_cb)(void*), void *cb_param)
1243 {
1244         struct ug_cbs cbs = {0};
1245         ui_gadget_h ug;
1246         service_h service;
1247         struct ug_priv_data *priv_data;
1248
1249         priv_data = calloc(1, sizeof(struct ug_priv_data));
1250         p_retvm_if(NULL == priv_data, NULL, "calloc is failed");
1251         priv_data->destroy_cb = destroy_cb;
1252         priv_data->cb_param = cb_param;
1253
1254         service_create(&service);
1255         service_add_extra_data(service, "mode", "account_list");
1256         service_add_extra_data(service, "capability_filter", ACCOUNT_SUPPORTS_CAPABILITY_CONTACT);
1257
1258         cbs.layout_cb = ug_common_layout_cb;
1259         cbs.result_cb = NULL;
1260         cbs.destroy_cb = ug_common_destroy_cb;
1261         cbs.priv = priv_data;
1262
1263         ug = ug_create(data, ACCOUNT_UG, UG_MODE_FULLVIEW, service, &cbs);
1264         p_warn_if(NULL == ug, "ug_create() Failed");
1265
1266         service_destroy(service);
1267         return ug;
1268 }
1269
1270 Evas_Object* phone_create_nocontents(Evas_Object *parent, const char* label)
1271 {
1272         Evas_Object *layout;
1273
1274         layout = elm_layout_add(parent);
1275         p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL");
1276
1277         elm_layout_theme_set(layout, "layout", "nocontents", "full");
1278         elm_object_part_text_set(layout, "elm.text", label);
1279
1280         return layout;
1281 }
1282
1283 void ctui_genlist_append_separator_20px_with_line(Evas_Object *genlist)
1284 {
1285         static Elm_Genlist_Item_Class itc = { .item_style="dialogue/separator/21/with_line"};
1286
1287         Elm_Object_Item *item;
1288         item = elm_genlist_item_append(genlist, &itc, NULL, NULL,
1289                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1290         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1291 }
1292
1293 void phone_toolbar_disabled_item_append(Evas_Object *toolbar, int cnt)
1294 {
1295         int i;
1296         Elm_Object_Item *item;
1297         for (i=0;i<cnt;i++) {
1298                 item = elm_toolbar_item_append(toolbar, NULL, NULL, NULL, NULL);
1299                 elm_object_item_disabled_set(item, EINA_TRUE);
1300         }
1301 }
1302
1303 void ctui_navi_left_btn_disabled_set(Elm_Object_Item *item, Eina_Bool disabled)
1304 {
1305         Evas_Object *btn;
1306         btn = elm_object_item_part_content_get(item, "title_left_btn");
1307         p_retm_if(NULL == btn, "elm_object_item_part_content_get() return NULL");
1308         elm_object_focus_set(btn, EINA_FALSE);
1309         elm_object_disabled_set(btn, disabled);
1310 }
1311
1312 int ctui_get_mfc_option(void)
1313 {
1314         int fd;
1315         int size;
1316         char buf[PH_TEXT_SHORT_LEN];
1317
1318         fd = open(SETTING_MFC_PATH, O_RDONLY);
1319         if(fd < 0){
1320                 ERR("Open(%s) O_RDONLY Failed", SETTING_MFC_PATH);
1321                 fd = open(SETTING_MFC_PATH, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1322                 p_retvm_if(fd < 0, 0, "Open(%s) Failed", SETTING_MFC_PATH);
1323                 if (-1 == write(fd, "0", 1))
1324                         ERR("write()... Failed(%s)", strerror(errno));
1325         }
1326         size = read(fd, buf, sizeof(buf));
1327         close(fd);
1328         if (0 < size)
1329                 return atoi(buf);
1330         else
1331                 return 0;
1332 }
1333
1334 static void genlist_selectall_mouseup_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
1335 {
1336         int x, y, w, h;
1337         Eina_Bool is_checked;
1338         Evas_Object *check;
1339         Evas_Event_Mouse_Up *ev = event_info;
1340         void *cb_data;
1341         selectall_changed_cb changed_cb = data;
1342
1343         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1344                 return;
1345
1346         evas_object_geometry_get(obj, &x, &y, &w, &h);
1347         if (ev->output.y < y || y + h < ev->output.y)
1348                 return;
1349
1350         p_retm_if(NULL == changed_cb, "changed_cb is NULL");
1351
1352         check = elm_object_part_content_get(obj, "elm.icon");
1353         p_retm_if(NULL == check, "elm_object_part_content_get() return NULL");
1354
1355         cb_data = evas_object_data_get(check, "cb_data");
1356         p_retm_if(NULL == cb_data, "cb_data is NULL");
1357
1358         is_checked = !elm_check_state_get(check);
1359         elm_check_state_set(check, is_checked);
1360
1361         changed_cb(cb_data, is_checked);
1362 }
1363
1364 static void genlist_selectall_changed_cb(void *data, Evas_Object *obj, void *event_info)
1365 {
1366         Eina_Bool is_checked;
1367         void *cb_data;
1368         selectall_changed_cb changed_cb = data;
1369         p_retm_if(NULL == changed_cb, "changed_cb is NULL");
1370
1371         cb_data = evas_object_data_get(obj, "cb_data");
1372         p_retm_if(NULL == cb_data, "cb_data is NULL");
1373
1374         is_checked = elm_check_state_get(obj);
1375         changed_cb(cb_data, is_checked);
1376 }
1377
1378 Evas_Object* phone_create_select_all(Evas_Object *parent, const char *selectall_text,
1379                 selectall_changed_cb changed_cb, void *cb_data)
1380 {
1381         Evas_Object *layout;
1382         Evas_Object *check;
1383
1384         p_retvm_if(NULL == parent, NULL, "parameter(parent) is NULL");
1385
1386         layout = elm_layout_add(parent);
1387         p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL");
1388         elm_layout_theme_set(layout, "genlist", "item", "select_all/default");
1389         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, 0);
1390         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
1391         evas_object_event_callback_add(layout, EVAS_CALLBACK_MOUSE_UP, genlist_selectall_mouseup_cb, changed_cb);
1392
1393         check = elm_check_add(layout);
1394         p_retvm_if(NULL == check, NULL, "elm_check_add() return NULL");
1395         evas_object_propagate_events_set(check, EINA_FALSE);
1396         elm_object_part_content_set(layout, "elm.icon", check);
1397         evas_object_smart_callback_add(check, "changed", genlist_selectall_changed_cb, changed_cb);
1398         evas_object_data_set(check, "cb_data", cb_data);
1399
1400         elm_object_part_text_set(layout, "elm.text", selectall_text);
1401         evas_object_show(layout);
1402
1403         return layout;
1404 }
1405
1406 void phone_move_ctxpopup(Evas_Object *popup, Evas_Object *item)
1407 {
1408         int x,y,w,h;
1409         int pos_x;
1410         int pos_y;
1411         p_retm_if(NULL == popup, "parameter(popup) is NULL");
1412         p_retm_if(NULL == item, "parameter(item) is NULL");
1413
1414         evas_object_geometry_get(item, &x, &y, &w, &h);
1415
1416         pos_x = x + (Evas_Coord)w/2;
1417         pos_y = y + (Evas_Coord)h/2;
1418
1419         evas_object_move(popup, pos_x, pos_y);
1420 }
1421
1422 void ctui_get_addressbook_name(int addressbook_id, char *dest, int dest_len)
1423 {
1424         char *display_name = NULL;
1425         contacts_error_e err = CONTACTS_ERROR_NONE;
1426         contacts_record_h record = NULL;
1427
1428         p_retm_if(NULL == dest, "parameter(dest) is NULL");
1429         dest[0] = '\0';
1430
1431         if (addressbook_id <= 0) {
1432                 snprintf(dest, dest_len, "%s", T_(CT_GET_TEXT_BASIC, CTTEXT_PHONE));
1433                 return;
1434         }
1435
1436         err = contacts_db_get_record(_contacts_address_book._uri, addressbook_id, &record);
1437         p_retm_if(CONTACTS_ERROR_NONE != err, "contacts_db_get_record() Failed(%d)", err);
1438
1439         err = contacts_record_get_str_p(record, _contacts_address_book.name, &display_name);
1440         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_get_str_p() Failed(%d)", err);
1441
1442         if (display_name && *display_name)
1443                 snprintf(dest, dest_len, "%s", display_name);
1444
1445         err = contacts_record_destroy(record, true);
1446         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1447 }
1448
1449 void ctui_get_account_name_by_address_book_id(int address_book_id, char *dest, int dest_len)
1450 {
1451         PH_FN_CALL;
1452         int ret;
1453         int account_id;
1454         char *domain_name;
1455         account_h account;
1456         contacts_error_e err = CONTACTS_ERROR_NONE;
1457         contacts_record_h record = NULL;
1458
1459         err = contacts_db_get_record(_contacts_address_book._uri, address_book_id, &record);
1460         p_retm_if(CONTACTS_ERROR_NONE != err, "phone_cts_get_list() Failed(%d)", err);
1461
1462         err = contacts_record_get_int(record, _contacts_address_book.account_id, &account_id);
1463         if (CONTACTS_ERROR_NONE != err) {
1464                 ERR("contacts_record_get_int() Failed(%d)", err);
1465                 err = contacts_record_destroy(record, true);
1466                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1467                 return;
1468         }
1469
1470         err = contacts_record_destroy(record, true);
1471         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1472
1473         if (0 == account_id)
1474                 return;
1475
1476         ret = account_connect();
1477         p_retm_if(ACCOUNT_ERROR_NONE != ret, "account_connect() Failed(%d)", ret);
1478
1479         account = NULL;
1480         ret = account_create(&account);
1481         if (ACCOUNT_ERROR_NONE != ret) {
1482                 ERR("account_create() Failed(%d)", ret);
1483                 account_disconnect();
1484                 return;
1485         }
1486
1487         ret = account_query_account_by_account_id(account_id, &account);
1488         if (ACCOUNT_ERROR_NONE != ret) {
1489                 ERR("account_query_account_by_account_id() Failed(%d)", ret);
1490                 account_destroy(account);
1491                 account_disconnect();
1492                 return;
1493         }
1494
1495         ret = account_get_domain_name(account, &domain_name);
1496         if (ACCOUNT_ERROR_NONE != ret) {
1497                 ERR("account_get_display_name() Failed(%d)", ret);
1498                 account_destroy(account);
1499                 account_disconnect();
1500                 return;
1501         }
1502         PH_DBG("domain_name = %s", domain_name);
1503
1504         account_destroy(account);
1505         account_disconnect();
1506
1507         if (domain_name && *domain_name)
1508                 snprintf(dest, dest_len, "%s", domain_name);
1509
1510         free(domain_name);
1511 }
1512
1513 // TODO: Fixme
1514 Eina_List* ctui_person_get_writable_contact_list(int person_id)
1515 {
1516         int addressbook_id;
1517         int addressbook_mode;
1518         Eina_List *list_contact_record = NULL;
1519
1520         contacts_error_e err = CONTACTS_ERROR_NONE;
1521         contacts_list_h list_contact = NULL;
1522         contacts_record_h record_addressbook = NULL;
1523         contacts_record_h record_contact = NULL;
1524         contacts_record_h record_contact_clone = NULL;
1525
1526         p_retvm_if(person_id <= 0, NULL, "Invalid parameter(%d)", person_id);
1527
1528         err = phone_cts_get_list(_contacts_contact._uri, _contacts_contact.person_id, person_id, &list_contact);
1529         p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "phone_cts_get_list() Failed(%d)", err);
1530
1531         while (CONTACTS_ERROR_NONE == err) {
1532                 err = phone_cts_get_int_from_list(list_contact, _contacts_contact.address_book_id, &addressbook_id);
1533                 if (CONTACTS_ERROR_NONE != err) {
1534                         ERR("phone_cts_get_int_from_list() Failed(%d)", err);
1535                         break;
1536                 }
1537
1538                 err = contacts_db_get_record(_contacts_address_book._uri, addressbook_id, &record_addressbook);
1539                 if (CONTACTS_ERROR_NONE != err) {
1540                         ERR("contacts_db_get_record() Failed(%d)", err);
1541                         break;
1542                 }
1543
1544                 err = contacts_record_get_int(record_addressbook, _contacts_address_book.mode, &addressbook_mode);
1545                 if (CONTACTS_ERROR_NONE != err) {
1546                         ERR("phone_cts_get_int_from_list() Failed(%d)", err);
1547                         err = contacts_record_destroy(record_addressbook, true);
1548                         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1549                         break;
1550                 }
1551
1552                 err = contacts_record_destroy(record_addressbook, true);
1553                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1554
1555                 // TODO: Fixme
1556                 if (1 == addressbook_mode)
1557                         continue;
1558
1559                 err = contacts_list_get_current_record_p(list_contact, &record_contact);
1560                 if (CONTACTS_ERROR_NONE != err) {
1561                         ERR("contacts_list_get_current_record_p() Failed(%d)", err);
1562                         break;
1563                 }
1564
1565                 err = contacts_record_clone(record_contact, &record_contact_clone);
1566                 if (CONTACTS_ERROR_NONE != err) {
1567                         ERR("contacts_record_clone() Failed(%d)", err);
1568                         break;
1569                 }
1570
1571                 list_contact_record = eina_list_append(list_contact_record, record_contact_clone);
1572
1573                 err = contacts_list_next(list_contact);
1574                 if (CONTACTS_ERROR_NONE != err) {
1575                         ERR("contacts_list_next() Failed(%d)", err);
1576                         break;
1577                 }
1578         }
1579         phone_cts_free_list(list_contact);
1580
1581         return list_contact_record;
1582 }
1583
1584 static bool __phone_list_is_email_exist(Eina_List *list, char *email_address)
1585 {
1586         Eina_List *l;
1587         char *email_address_temp;
1588         contacts_error_e err = CONTACTS_ERROR_NONE;
1589         contacts_record_h record_temp = NULL;
1590
1591         EINA_LIST_FOREACH(list, l, record_temp) {
1592                 if (NULL == record_temp)
1593                         continue;
1594
1595                 err = contacts_record_get_str_p(record_temp, _contacts_email.email, &email_address_temp);
1596                 p_retvm_if(CONTACTS_ERROR_NONE != err, false, "contacts_record_get_str_p() Failed(%d)", err);
1597
1598                 if (NULL == email_address_temp)
1599                         continue;
1600
1601                 if (0 == strcmp(email_address_temp, email_address))
1602                         return true;
1603         }
1604         return false;
1605 }
1606
1607 Eina_List* ctui_person_get_email_list(Eina_List *contact_list)
1608 {
1609         Eina_Bool checkduplicate = false;
1610         int index = 0;
1611         char *email_address;
1612         Eina_List *l;
1613         Eina_List *list_email_record = NULL;
1614         contacts_error_e err = CONTACTS_ERROR_NONE;
1615         contacts_record_h record = NULL;
1616         contacts_record_h record_email = NULL;
1617         contacts_record_h record_clone = NULL;
1618
1619         EINA_LIST_FOREACH(contact_list, l, record) {
1620                 index = 0;
1621                 while (CONTACTS_ERROR_NONE == contacts_record_get_child_record_at_p(record, _contacts_contact.email, index++, &record_email)) {
1622                         err = contacts_record_get_str_p(record_email, _contacts_email.email, &email_address);
1623                         if (CONTACTS_ERROR_NONE != err) {
1624                                 ERR("phone_cts_get_str_from_list() Failed(%d)", err);
1625                                 break;
1626                         }
1627                         if( checkduplicate ){
1628                                 if (__phone_list_is_email_exist(list_email_record, email_address)) {
1629                                         ERR("__phone_list_is_email_exist() return true (email address = %s", email_address);
1630                                         continue;
1631                                 }
1632                         }
1633                         err = contacts_record_clone(record_email, &record_clone);
1634                         if (CONTACTS_ERROR_NONE != err) {
1635                                 ERR("contacts_list_get_current_record_p() Failed(%d)", err);
1636                                 break;
1637                         }
1638                         list_email_record = eina_list_append(list_email_record, record_clone);
1639                 }
1640                 checkduplicate = true;
1641         }
1642         return list_email_record;
1643 }
1644
1645 static bool __phone_list_is_number_exist(Eina_List *list, char *number_str)
1646 {
1647         Eina_List *l;
1648         char *number_str_temp;
1649         contacts_error_e err = CONTACTS_ERROR_NONE;
1650         contacts_record_h record_temp = NULL;
1651
1652         EINA_LIST_FOREACH(list, l, record_temp) {
1653                 if (NULL == record_temp)
1654                         continue;
1655
1656                 err = contacts_record_get_str_p(record_temp, _contacts_number.number, &number_str_temp);
1657                 p_retvm_if(CONTACTS_ERROR_NONE != err, false, "contacts_record_get_str_p() Failed(%d)", err);
1658
1659                 if (NULL == number_str_temp)
1660                         continue;
1661
1662                 if (0 == strcmp(number_str_temp, number_str))
1663                         return true;
1664         }
1665         return false;
1666 }
1667
1668 Eina_List* ctui_person_get_number_list(Eina_List *contact_list)
1669 {
1670         Eina_Bool checkduplicate = false;
1671         int index = 0;
1672         char *number_str;
1673         Eina_List *l;
1674         Eina_List *list_number_record = NULL;
1675         contacts_error_e err = CONTACTS_ERROR_NONE;
1676         contacts_record_h record = NULL;
1677         contacts_record_h record_number = NULL;
1678         contacts_record_h record_clone = NULL;
1679
1680         EINA_LIST_FOREACH(contact_list, l, record) {
1681                 index = 0;
1682                 while (CONTACTS_ERROR_NONE == contacts_record_get_child_record_at_p(record, _contacts_contact.number, index++, &record_number)) {
1683                         err = contacts_record_get_str_p(record_number, _contacts_number.number, &number_str);
1684                         if (CONTACTS_ERROR_NONE != err) {
1685                                 ERR("phone_cts_get_str_from_list() Failed(%d)", err);
1686                                 break;
1687                         }
1688                         if( checkduplicate ){
1689                                 if (__phone_list_is_number_exist(list_number_record, number_str)) {
1690                                         ERR("__phone_list_is_number_exist() return true (number = %s", number_str);
1691                                         continue;
1692                                 }
1693                         }
1694                         err = contacts_record_clone(record_number, &record_clone);
1695                         if (CONTACTS_ERROR_NONE != err) {
1696                                 ERR("contacts_list_get_current_record_p() Failed(%d)", err);
1697                                 break;
1698                         }
1699                         list_number_record = eina_list_append(list_number_record, record_clone);
1700                 }
1701                 checkduplicate = true;
1702         }
1703         return list_number_record;
1704 }
1705
1706 Eina_List* ctui_person_get_contact_list(int person_id)
1707 {
1708         contacts_error_e err = CONTACTS_ERROR_NONE;
1709         contacts_record_h record_contact = NULL;
1710         contacts_record_h record_contact_clone = NULL;
1711         contacts_list_h list_contacts = NULL;
1712         Eina_List *list_contact_records = NULL;
1713
1714         err = phone_cts_get_list(_contacts_contact._uri, _contacts_contact.person_id, person_id, &list_contacts);
1715         p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "phone_cts_get_list() Failed(%d)", err);
1716
1717         while (err == CONTACTS_ERROR_NONE) {
1718                 err = contacts_list_get_current_record_p(list_contacts, &record_contact);
1719                 if (CONTACTS_ERROR_NONE != err) {
1720                         ERR("contacts_list_get_current_record_p() Failed(%d)", err);
1721                         break;
1722                 }
1723
1724                 err = contacts_record_clone(record_contact, &record_contact_clone);
1725                 if (CONTACTS_ERROR_NONE != err) {
1726                         ERR("contacts_record_clone() Failed(%d)", err);
1727                         break;
1728                 }
1729
1730                 list_contact_records = eina_list_append(list_contact_records, record_contact_clone);
1731
1732                 err = contacts_list_next(list_contacts);
1733                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_next() Failed(%d)", err);
1734         }
1735         phone_cts_free_list(list_contacts);
1736
1737         return list_contact_records;
1738 }
1739
1740 void ctui_free_record_list(Eina_List *contact_list)
1741 {
1742         contacts_error_e err = CONTACTS_ERROR_NONE;
1743         contacts_record_h record = NULL;
1744         p_retm_if(NULL == contact_list, "contact_list is NULL");
1745
1746         EINA_LIST_FREE(contact_list, record) {
1747                 if (NULL == record) continue;
1748                 err = contacts_record_destroy(record, true);
1749                 if (CONTACTS_ERROR_NONE != err) {
1750                         ERR("contacts_record_destroy() Failed(%d)", err);
1751                         continue;
1752                 }
1753         }
1754 }
1755
1756 // TODO: Fixme
1757 int ctui_get_email_type_index(int type)
1758 {
1759         switch (type) {
1760         case CONTACTS_EMAIL_TYPE_CUSTOM:
1761                 return 1;
1762         case CONTACTS_EMAIL_TYPE_HOME:
1763                 return 2;
1764         case CONTACTS_EMAIL_TYPE_WORK:
1765                 return 3;
1766         default:
1767                 return 0;
1768         }
1769 }
1770
1771 int ctui_get_view_mode(void)
1772 {
1773         PH_FN_CALL;
1774         int fd;
1775         int size;
1776         char buf[PH_TEXT_SHORT_LEN];
1777
1778         fd = open(VIEW_MODE_PATH, O_RDONLY);
1779         if(fd < 0) {
1780                 ctui_set_view_mode(-1);
1781                 PH_DBG("Open(%s) Failed so create new", VIEW_MODE_PATH);
1782                 return -1;
1783         }
1784         size = read(fd, buf, sizeof(buf));
1785         close(fd);
1786         if (0 < size)
1787                 return atoi(buf);
1788         else
1789                 return -1;
1790 }
1791
1792 void ctui_set_view_mode(int addressbook_id)
1793 {
1794         PH_FN_CALL;
1795         int fd;
1796         char buf[PH_TEXT_SHORT_LEN] = {0};
1797
1798         fd = open(VIEW_MODE_PATH, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1799         p_retm_if(fd < 0, "Open(%s) Failed", VIEW_MODE_PATH);
1800         snprintf(buf, sizeof(buf), "%d",addressbook_id);
1801         if (-1 == write(fd, buf, strlen(buf)))
1802                 ERR("write()... Failed(%s)", strerror(errno));
1803         close(fd);
1804 }
1805
1806 contacts_error_e phone_cts_get_default_number(int person_id, contacts_record_h *record_clone)
1807 {
1808         contacts_error_e err = CONTACTS_ERROR_NONE;
1809         contacts_record_h record = NULL;
1810         contacts_list_h list = NULL;
1811         contacts_filter_h filter = NULL;
1812         contacts_query_h query = NULL;
1813
1814         p_retvm_if(NULL == record_clone, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(record_clone) is NULL");
1815
1816         err = contacts_query_create(_contacts_person_number._uri, &query);
1817         p_retvm_if(CONTACTS_ERROR_NONE != err, err, "contacts_query_create() Failed(%d)", err);
1818
1819         err = contacts_filter_create(_contacts_person_number._uri, &filter);
1820         if (CONTACTS_ERROR_NONE != err) {
1821                 ERR("contacts_filter_create() Failed(%d)", err);
1822                 contacts_query_destroy(query);
1823                 return err;
1824         }
1825
1826         do {
1827                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_int(filter, _contacts_person_number.person_id, CONTACTS_MATCH_EQUAL, person_id))) break;
1828                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_AND))) break;
1829                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_bool(filter, _contacts_person_number.is_primary_default, true))) break;
1830                 if (CONTACTS_ERROR_NONE != (err = contacts_query_set_filter(query, filter))) break;
1831                 if (CONTACTS_ERROR_NONE != (err = contacts_db_get_records_with_query(query, 0, 0, &list))) break;
1832                 if (CONTACTS_ERROR_NONE != (err = contacts_list_get_current_record_p(list, &record))) break;
1833                 if (CONTACTS_ERROR_NONE != (err = contacts_record_clone(record, record_clone))) break;
1834
1835                 contacts_query_destroy(query);
1836                 contacts_filter_destroy(filter);
1837                 contacts_list_destroy(list, true);
1838
1839                 return CONTACTS_ERROR_NONE;
1840         } while (0);
1841
1842         contacts_query_destroy(query);
1843         contacts_filter_destroy(filter);
1844         if (list)
1845                 contacts_list_destroy(list, true);
1846
1847         return err;
1848 }
1849
1850 contacts_error_e phone_cts_get_default_email(int person_id, contacts_record_h *record_clone)
1851 {
1852         contacts_error_e err = CONTACTS_ERROR_NONE;
1853         contacts_record_h record = NULL;
1854         contacts_list_h list = NULL;
1855         contacts_filter_h filter = NULL;
1856         contacts_query_h query = NULL;
1857
1858         p_retvm_if(NULL == record_clone, CONTACTS_ERROR_INVALID_PARAMETER, "parameter(record_clone) is NULL");
1859
1860         err = contacts_query_create(_contacts_person_email._uri, &query);
1861         p_retvm_if(CONTACTS_ERROR_NONE != err, err, "contacts_query_create() Failed(%d)", err);
1862
1863         err = contacts_filter_create(_contacts_person_email._uri, &filter);
1864         if (CONTACTS_ERROR_NONE != err) {
1865                 ERR("contacts_filter_create() Failed(%d)", err);
1866                 contacts_query_destroy(query);
1867                 return err;
1868         }
1869
1870         do {
1871                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_int(filter, _contacts_person_email.person_id, CONTACTS_MATCH_EQUAL, person_id))) break;
1872                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_operator(filter, CONTACTS_FILTER_OPERATOR_AND))) break;
1873                 if (CONTACTS_ERROR_NONE != (err = contacts_filter_add_bool(filter, _contacts_person_email.is_primary_default, true))) break;
1874                 if (CONTACTS_ERROR_NONE != (err = contacts_query_set_filter(query, filter))) break;
1875                 if (CONTACTS_ERROR_NONE != (err = contacts_db_get_records_with_query(query, 0, 0, &list))) break;
1876                 if (CONTACTS_ERROR_NONE != (err = contacts_list_get_current_record_p(list, &record))) break;
1877                 if (CONTACTS_ERROR_NONE != (err = contacts_record_clone(record, record_clone))) break;
1878
1879                 contacts_query_destroy(query);
1880                 contacts_filter_destroy(filter);
1881                 contacts_list_destroy(list, true);
1882
1883                 return CONTACTS_ERROR_NONE;
1884         } while (0);
1885
1886         contacts_query_destroy(query);
1887         contacts_filter_destroy(filter);
1888
1889         if (list)
1890                 contacts_list_destroy(list, true);
1891         return err;
1892 }
1893
1894 bool ctui_list_make_vcard(int person_id, char *path, int path_length)
1895 {
1896         int fd;
1897         char *display = NULL;
1898         char *vcard = NULL;
1899         contacts_record_h record = NULL;
1900         contacts_error_e err = CONTACTS_ERROR_NONE;
1901
1902         err = contacts_db_get_record(_contacts_person._uri, person_id, &record);
1903         if (CONTACTS_ERROR_NONE != err) {
1904                 ERR("contacts_db_get_record() Failed(%d)", err);
1905                 return false;
1906         }
1907
1908         err = contacts_record_get_str_p(record, _contacts_person.display_name, &display);
1909         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_get_str_p() Failed(%d)", err);
1910
1911         if (display && *display)
1912                 snprintf(path, path_length, "%s/%s.vcf", UGDATAIDR, display);
1913         else
1914                 snprintf(path, path_length, "%s/%s.vcf", UGDATAIDR, T_(CT_GET_TEXT_ERR, CTTEXT_NONAME));
1915
1916         err = contacts_vcard_make_from_person(record, &vcard);
1917         if (CONTACTS_ERROR_NONE != err) {
1918                 ERR("contacts_vcard_make_from_person() Failed(%d)", err);
1919                 err = contacts_record_destroy(record, true);
1920                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_destroy() Failed(%d)", err);
1921                 return false;
1922         }
1923
1924         fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1925
1926         if (-1 == write(fd, vcard, strlen(vcard))) {
1927                 ERR("write()... Failed(%s)", strerror(errno));
1928                 free(vcard);
1929                 return false;
1930         }
1931         free(vcard);
1932         return true;
1933 }
1934
1935
1936 int ctui_get_addressbook_id_by_index(Eina_List *list, int index)
1937 {
1938         p_retvm_if(NULL == list, -1, "list is NULL");
1939         void *addressbook_id;
1940
1941         if(eina_list_count(list) <= index)
1942         {
1943                 ERR("index is bigger than count");
1944                 return -1;
1945         }
1946
1947         addressbook_id = eina_list_nth(list, index);
1948
1949         return (int)addressbook_id;
1950 }
1951
1952 Eina_List* ctui_get_addressbook_id_list(const char *ori_string, const char *sep)
1953 {
1954         Eina_List *e_list = NULL;
1955         char *p = NULL;
1956         char *copy_string;
1957         char *save_p;
1958
1959         if (!ori_string) {
1960                 PH_DBG("Input string is NULL");
1961                 return NULL;
1962         }
1963
1964         copy_string = SAFE_STRDUP(ori_string);
1965
1966         if (copy_string) {
1967                 p = strtok_r(copy_string, sep, &save_p);
1968
1969                 while (p) {
1970                         int id = atoi(p);
1971                         if(eina_list_data_find(e_list, (void*)id) == NULL)
1972                                 e_list = eina_list_append(e_list, (void*)id);
1973
1974                         p = strtok_r(NULL, sep, &save_p);
1975                 }
1976
1977                 free(copy_string);
1978         }
1979
1980         return e_list;
1981 }
1982
1983
1984 Eina_List* __make_tokenize_list(const char *ori_string, const char *sep)
1985 {
1986         Eina_List *e_list = NULL;
1987         char *p = NULL;
1988         char *copy_string;
1989         char *save_p;
1990
1991         if (!ori_string) {
1992                 PH_DBG("Input string is NULL");
1993                 return NULL;
1994         }
1995
1996         copy_string = SAFE_STRDUP(ori_string);
1997
1998         if (copy_string) {
1999                 p = strtok_r(copy_string, sep, &save_p);
2000
2001                 if (p)
2002                         PH_DBG("list item = %s", p);
2003
2004                 while (p) {
2005                         char *c = SAFE_STRDUP(p);
2006
2007                         e_list = eina_list_append(e_list, c);
2008
2009                         p = strtok_r(NULL, sep, &save_p);
2010
2011                         if (p)
2012                                 PH_DBG("list item = %s", p);
2013                 }
2014
2015                 free(copy_string);
2016         }
2017
2018         return e_list;
2019 }
2020
2021
2022
2023 contacts_record_h ctui_get_record_image(contacts_record_h record_contact)
2024 {
2025         PH_FN_CALL;
2026         contacts_error_e err = CONTACTS_ERROR_NONE;
2027         contacts_record_h record = NULL;
2028         p_retvm_if(NULL == record_contact, NULL, "parameter(record_contact) is NULL");
2029
2030         err = contacts_record_get_child_record_at_p(record_contact, _contacts_contact.image, 0, &record);
2031         if (NULL != record)     return record;
2032
2033         err = contacts_record_create(_contacts_image._uri, &record);
2034         p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "contacts_record_create() Failed(%d)", err);
2035
2036         err = contacts_record_add_child_record(record_contact, _contacts_contact.image, record);
2037         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_record_add_child_record() Failed(%d)", err);
2038
2039         return record;
2040 }
2041
2042
2043 Evas_Object *phone_create_toolbar_btn(Evas_Object *parent, const char *text, Evas_Smart_Cb func, void *data)
2044 {
2045         Evas_Object *btn = elm_button_add(parent);
2046         if (!btn) return NULL;
2047         elm_object_style_set(btn, "naviframe/toolbar/default");
2048         elm_object_text_set(btn, text);
2049         evas_object_smart_callback_add(btn, "clicked", func, data);
2050         return btn;
2051 }
2052
2053 Evas_Object* ctui_create_more_btn(Evas_Object *parent, Evas_Smart_Cb func, void *data)
2054 {
2055         Evas_Object *btn = elm_button_add(parent);
2056         if (!btn) return NULL;
2057         elm_object_style_set(btn, "naviframe/more/default");
2058         evas_object_smart_callback_add(btn, "clicked", func, data);
2059         return btn;
2060 }
2061
2062 int ctui_get_addressbook_id(char* addressbook_name)
2063 {
2064         PH_FN_CALL;
2065         PH_DBG("addressbook_name = %s", addressbook_name);
2066         contacts_error_e err = CONTACTS_ERROR_NONE;
2067         contacts_filter_h filter = NULL;
2068         contacts_query_h query = NULL;
2069         contacts_list_h list = NULL;
2070         contacts_record_h record = NULL;
2071         unsigned int count =0;
2072         int addressbook_id =-1;//0 is phone addressbook id
2073
2074         err = contacts_filter_create(_contacts_address_book._uri, &filter);
2075         p_warn_if(CONTACTS_ERROR_NONE != err, "contactcs_filter_create() Failed(%d)", err);
2076
2077
2078         err = contacts_filter_add_str(filter,_contacts_address_book.name , CONTACTS_MATCH_FULLSTRING, addressbook_name);
2079         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_filter_add_str() Failed(%d)", err);
2080         err = contacts_query_create(_contacts_address_book._uri, &query);
2081         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_create() Failed(%d)", err);
2082         err = contacts_query_set_filter(query, filter);
2083         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_set_filter() Failed(%d)", err);
2084         err = contacts_db_get_records_with_query(query, 0, 0, &list);
2085         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_db_get_records_with_query() Failed(%d)", err);
2086
2087         if(list != NULL)
2088         {
2089                 err = contacts_list_get_count(list,&count );
2090                 p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_get_count() Failed(%d)", err);
2091                 PH_DBG("count = %d",count);
2092                 if(count > 0){
2093                         err = contacts_list_get_current_record_p(list, &record);
2094                         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_get_current_record_p() Failed(%d)", err);
2095                         contacts_record_get_int(record,_contacts_address_book.id,&addressbook_id);
2096                         err = contacts_list_destroy(list,true);
2097                         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_destroy() Failed(%d)", err);
2098                 }
2099         }
2100         err = contacts_filter_destroy(filter);
2101         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_filter_destroy() Failed(%d)", err);
2102         err = contacts_query_destroy(query);
2103         p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_destroy() Failed(%d)", err);
2104
2105         PH_DBG("addressbook id = %d",addressbook_id);
2106         return addressbook_id;
2107
2108 }
2109
2110 void ctui_create_contacts_error_popup(Evas_Object *parent, int err)
2111 {
2112         p_retm_if(CONTACTS_ERROR_NONE == err, "ctui_create_contacts_error_popup no errer");
2113         p_retm_if(NULL == parent, "ctui_create_contacts_error_popup parent is null");
2114
2115         ERR("ctui_create_contacts_error_popup() err(%d)", err);
2116         switch (err) {
2117         case CONTACTS_ERROR_DB:
2118                 phone_show_popup(parent, T_(CT_GET_TEXT_ERR, CTTEXT_ERR_DB_LOCKED), 1.5);
2119                 break;
2120         case CONTACTS_ERROR_FILE_NO_SPACE:
2121                 phone_show_popup(parent, S_(CT_SYS_POP_NOT_ENOUGH_MEMORY), 1.5);
2122                 break;
2123         default:
2124                 phone_show_popup(parent, S_(PH_SYS_POP_FAILED), 1.5);
2125                 break;
2126         }
2127
2128         return;
2129
2130 }
2131