diff options
Diffstat (limited to 'lib/common/ph-common.cpp')
| -rwxr-xr-x | lib/common/ph-common.cpp | 3667 |
1 files changed, 3667 insertions, 0 deletions
diff --git a/lib/common/ph-common.cpp b/lib/common/ph-common.cpp new file mode 100755 index 0000000..23951dc --- /dev/null +++ b/lib/common/ph-common.cpp @@ -0,0 +1,3667 @@ +/* + * Copyright 2012 Samsung Electronics Co., Ltd + * + * Licensed under the Flora License, Version 1.1 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://floralicense.org/license/ + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <app.h> +#include <fcntl.h> +#include <ui-gadget-module.h> +#include <account-types.h> +#include <syspopup_caller.h> +#include <account.h> +#include <notification.h> +#include <cctype> +#include <algorithm> +#include <unicode/ustring.h> +#include <unicode/udatpg.h> +#include <msg.h> +#include <msg_types.h> + +#include "phone.h" +#include "phone-common.h" + +#include <badge.h> + +#define CT_CBAR_ITEM_MAX 4 +#define LAUNCH_TYPE "launch-type" +#define SEND "send" +#define EMERGENCY "emergency" +#define FILES "files" +#define FILECOUNT 1 +#define DEF_MAX_FILTER_LEN (40) +#define DEF_BUF_LEN (512) +#define CALL_APP "org.tizen.call" + +std::string ct_make_uppercase_string(const std::string& inputStr) +{ + std::string retStr; + retStr.reserve(inputStr.size()); + std::transform(inputStr.begin(), inputStr.end(), std::back_inserter(retStr), toupper); + return retStr; +} + +/** + * @brief Overloaded function for adding string filter + * @param filter DB filter handle + * @param filterField Link to field + * @param strVal The string value to which filtering is performed + * @return Returns true if filter was added, otherwise false + */ +bool add_filter_field(contacts_filter_h filter, unsigned int filterField, const std::string& strVal) +{ + PH_TRACE; + return (contacts_filter_add_str(filter, filterField, CONTACTS_MATCH_ENDSWITH, strVal.c_str()) == CONTACTS_ERROR_NONE); +} + +/** + * @brief Overloaded function for adding integer filter + * @param filter DB filter handle + * @param filterField Link to field + * @param intVal The integer value to which filtering is performed + * @return Returns true if filter was added, otherwise false + */ +bool add_filter_field(contacts_filter_h filter, unsigned int filterField, int intVal) +{ + PH_TRACE; + return (contacts_filter_add_int(filter, filterField, CONTACTS_MATCH_EQUAL, intVal) == CONTACTS_ERROR_NONE); +} + +template < typename FilterFieldType> +bool get_records_list(const std::string& tableUri, unsigned int filterField, + FilterFieldType filterVal, contacts_list_h* list) +{ + PH_TRACE; + contacts_query_h query = NULL; + contacts_filter_h filter = NULL; + contacts_list_h innerList = NULL; + bool result(false); + + if(contacts_query_create(tableUri.c_str(), &query) == CONTACTS_ERROR_NONE) + { + if(contacts_filter_create(tableUri.c_str(), &filter) == CONTACTS_ERROR_NONE) + { + if(add_filter_field(filter, filterField, filterVal)) + { + if(contacts_query_set_filter(query, filter) == CONTACTS_ERROR_NONE) + { + if(contacts_db_get_records_with_query(query, 0, 0, &innerList) == CONTACTS_ERROR_NONE) + { + unsigned int count(0); + contacts_list_get_count(innerList, &count); + if(count > 0) + { + result = true; + } + } + } + } + } + } + result &= contacts_query_destroy(query) == CONTACTS_ERROR_NONE; + result &= contacts_filter_destroy(filter) == CONTACTS_ERROR_NONE; + if(result) + { + if(*list) + { + contacts_list_destroy(*list, true); + } + *list = innerList; + } + else + { + contacts_list_destroy(innerList, true); + ERR("List of records is not obtained"); + } + + return result; +} + +bool phone_toggle_blocked_contact_for_calls(int contactId) +{ + PH_TRACE; + bool result(false); + if (contactId > notRelatedToContactId) + { + contacts_list_h recList = NULL; + if (get_records_list(_contacts_contact._uri, _contacts_contact.id, contactId, &recList)) + { + contacts_record_h contactRec = NULL; + contacts_record_h extensionRec = NULL; + if (contacts_list_get_current_record_p(recList, &contactRec) == CONTACTS_ERROR_NONE) + { + if (contacts_record_create(_contacts_extension._uri, &extensionRec) == CONTACTS_ERROR_NONE) + { + unsigned int extensionsCount(0); + if (contacts_record_get_child_record_count(contactRec, _contacts_contact.extension, &extensionsCount) + == CONTACTS_ERROR_NONE) + { + DBG("Extensions count: %u", extensionsCount); + if (0 == extensionsCount) + { + result = ct_list_insert_extension(extensionRec, _contacts_extension.data2, contactId, ct_list_bool_to_str(true)); + if (!result) + { + ERR("Extension is not inserted"); + } + } + else + { + result = ct_list_toggle_blocked(contactRec, extensionRec); + if (!result) + { + ERR("Extension is not updated"); + } + } + } + if (contacts_record_destroy(extensionRec, true) + != CONTACTS_ERROR_NONE) + { + ERR("Record is not destroyed"); + } + } + } + if (contacts_list_destroy(recList, true) != CONTACTS_ERROR_NONE) + { + ERR("List is not destroyed"); + } + } + } + return result; +} + +int phone_get_extension_id(int contactId) +{ + PH_TRACE; + int result(incorrectId); + contacts_list_h recList = NULL; + if(get_records_list(_contacts_contact._uri, _contacts_contact.id, contactId, &recList)) + { + contacts_record_h contactRec = NULL; + if(contacts_list_get_current_record_p(recList, &contactRec) == CONTACTS_ERROR_NONE) + { + unsigned int extensionsCount(0); + if(contacts_record_get_child_record_count(contactRec, _contacts_contact.extension, &extensionsCount) + == CONTACTS_ERROR_NONE) + { + if(extensionsCount > 0) + { + contacts_record_h extensionRec = NULL; + if(contacts_record_get_child_record_at_p(contactRec, _contacts_contact.extension, + 0, &extensionRec) == CONTACTS_ERROR_NONE) + { + int extensionId(incorrectId); + if(contacts_record_get_int(extensionRec, _contacts_extension.id, + &extensionId) == CONTACTS_ERROR_NONE) + { + result = extensionId; + } + } + } + } + } + if(contacts_list_destroy(recList, true) + != CONTACTS_ERROR_NONE) + { + ERR("List is not destroyed"); + } + } + return result; +} + +bool phone_is_blocked_contact_for_calls(int contactId) +{ + PH_TRACE; + bool result(false); + int extensionId = phone_get_extension_id(contactId); + if(extensionId > -1) + { + contacts_list_h extensionList = NULL; + if(get_records_list(_contacts_extension._uri, _contacts_extension.id, extensionId, &extensionList)) + { + contacts_record_h extensionRecord = NULL; + if(contacts_list_get_current_record_p(extensionList, &extensionRecord) + == CONTACTS_ERROR_NONE) + { + char* isBlocked = NULL; + if(contacts_record_get_str(extensionRecord, _contacts_extension.data2, &isBlocked) + == CONTACTS_ERROR_NONE) + { + result = ct_list_str_to_bool(isBlocked); + } + free(isBlocked); + } + contacts_list_destroy(extensionList, true); + } + } + return result; +} + +static void progress_popup_cancel_cb(void *data, Evas_Object *obj, + void *event_info) +{ + PH_TRACE; + bool *is_alive = (bool *) data; + *is_alive = false; +} + +void phone_free_contacts(Eina_List *list) +{ + PH_TRACE; + Eina_List *l; + void *v_cd; + + p_retm_if(NULL == list, "list is NULL"); + + EINA_LIST_FOREACH(list, l, v_cd) + { + ph_contact_d *cd = (ph_contact_d *) v_cd; + if (NULL == cd) + continue; + + free(cd->display); + free(cd->img_path); + free(cd->number); + free(cd); + } + eina_list_free(list); +} + +void ctui_list_edit_navi_pop(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + int cnt_checked; + int person_count = 0; + int number_count = 0; + int email_count = 0; + int *result_list_number = NULL; + int *result_list_email = NULL; + int *result_list_person = NULL; + Eina_List *l; + ct_list_data *clist_d = (ct_list_data *) data; + void *info; + + cnt_checked = ctui_list_checked_cnt_get(clist_d->list); + + PH_DBG("clist_d->ug_request %d count %d", clist_d->ug_request, cnt_checked); + if (CT_UG_REQUEST_CHECK_FOR_NUMBER == clist_d->ug_request) + result_list_number = (int *) calloc(cnt_checked, sizeof(int)); + else if (CT_UG_REQUEST_CHECK_FOR_EMAIL == clist_d->ug_request) + result_list_email = (int *) calloc(cnt_checked, sizeof(int)); + else if (CT_UG_REQUEST_CHECK_FOR_NUMBER_OR_EMAIL == clist_d->ug_request) + { + result_list_number = (int *) calloc(cnt_checked, sizeof(int)); + result_list_email = (int *) calloc(cnt_checked, sizeof(int)); + } + else + result_list_person = (int *) calloc(cnt_checked, sizeof(int)); + + EINA_LIST_FOREACH(clist_d->list, l, info) + { + ct_person_list *person_info = (ct_person_list *) info; + if (NULL == person_info || !person_info->checked) + continue; + if (1 == person_info->id_ret_type) + result_list_number[number_count++] = person_info->id_ret; + else if (2 == person_info->id_ret_type) + result_list_email[email_count++] = person_info->id_ret; + else + result_list_person[person_count++] = person_info->id; + } + + // setting - import,export / group-view - message,email,chaton,calendar + if (clist_d->select_result_cb) + { // called by setting view - check person_info + if (0 < cnt_checked) + { + if (result_list_number) + clist_d->select_result_cb(clist_d->select_result_cb_data, + result_list_number, number_count); + else if (result_list_email) + clist_d->select_result_cb(clist_d->select_result_cb_data, + result_list_email, email_count); + else + clist_d->select_result_cb(clist_d->select_result_cb_data, + result_list_person, person_count); + } + } + if (result_list_person) + free(result_list_person); + if (result_list_number) + free(result_list_number); + if (result_list_email) + free(result_list_email); +} + +void ug_common_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv) +{ + PH_TRACE; + Evas_Object *base; + + if (!ug) + return; + + base = (Evas_Object *) ug_get_layout(ug); + if (!base) + { + ERR("ug_get_layout() return NULL"); + ug_destroy(ug); + return; + } + evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show(base); +} + +void ug_common_destroy_cb(ui_gadget_h ug, void *priv) +{ + PH_TRACE; + struct ug_priv_data *priv_data; + + p_retm_if(NULL == ug, "ug is NULL"); + ug_destroy(ug); + + p_retm_if(NULL == priv, "priv is NULL"); + + priv_data = (struct ug_priv_data *) priv; + + if (priv_data->destroy_cb) + priv_data->destroy_cb(priv_data->cb_param); + + free(priv); + +} + +ui_gadget_h phone_image_crop_ug(ui_gadget_h parent, const char *photo, + struct ug_cbs *cbs) +{ + PH_TRACE; + ui_gadget_h ug; + + service_h service; + + service_create(&service); + service_add_extra_data(service, "Path", photo); + service_add_extra_data(service, "View Mode", "SETAS"); + service_add_extra_data(service, "Setas type", "CallerID"); + service_add_extra_data(service, "Area Size", "100"); + + cbs->layout_cb = ug_common_layout_cb; + + ug = ug_create(parent, IMG_VIEWER_UG, UG_MODE_FULLVIEW, service, cbs); + p_warn_if(NULL == ug, "ug_create() Failed"); + + service_destroy(service); + + return ug; +} + +ui_gadget_h phone_launch_msg_composer_ug(ui_gadget_h parent_ug, char *number, int msg_id, + void (*destroy_cb)(void*), void *cb_param) +{ + PH_TRACE; + ui_gadget_h ug; + struct ug_cbs cbs = { 0 }; + struct ug_priv_data *priv_data; + service_h service; + char ret[PH_TEXT_MAX_LEN] = { 0 }; + + priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + if (number && *number) + service_add_extra_data(service, "TO", (char*) number); + else if (msg_id) + { + service_add_extra_data(service, "type", "msg_id"); + snprintf(ret, sizeof(ret), "%d", msg_id); + service_add_extra_data(service, "msgId", ret); + } + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ug = ug_create((ui_gadget_h) parent_ug, MSG_COMPOSER_UG, UG_MODE_FULLVIEW, service, &cbs); + service_destroy(service); + + if (ug == NULL) + { + free(priv_data); + ERR("%s ug_create is failed", MSG_COMPOSER_UG); + } + return ug; +} + +ui_gadget_h phone_launch_contact_detail_ug(ui_gadget_h parent_ug, int contact_index, + void (*destroy_cb)(void*), void *cb_param) +{ + PH_TRACE; + char buf[PH_TEXT_MAX_LEN] = { 0 }; + struct ug_cbs cbs = { 0 }; + service_h service; + ui_gadget_h ug; + struct ug_priv_data *priv_data; + + priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + + snprintf(buf, sizeof(buf), "%d", contact_index); + service_add_extra_data(service, CT_UG_BUNDLE_ID, buf); + snprintf(buf, sizeof(buf), "%d", CT_UG_REQUEST_DETAIL); + service_add_extra_data(service, CT_UG_BUNDLE_TYPE, buf); + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ug = ug_create((ui_gadget_h) parent_ug, UG_CONTACTS_DETAILS, UG_MODE_FULLVIEW, service, + &cbs); + service_destroy(service); + + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", UG_CONTACTS_DETAILS); + } + return ug; +} + +ui_gadget_h phone_launch_contact_add_list_edit_ug(ui_gadget_h parent_ug, char *data, + void (*destroy_cb)(void *), void *cb_param) +{ + PH_TRACE; + char buf[PH_TEXT_MAX_LEN] = { 0 }; + struct ug_cbs cbs = { 0 }; + struct ug_priv_data *priv_data; + ui_gadget_h ug; + service_h service; + + priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + + snprintf(buf, sizeof(buf), "%d", CT_UG_REQUEST_UPDATE_WITH_NUM); + service_add_extra_data(service, CT_UG_BUNDLE_TYPE, buf); + snprintf(buf, sizeof(buf), "%s", data); + service_add_extra_data(service, CT_UG_BUNDLE_NUM, buf); + PH_DBG("number %s", buf); + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ug = ug_create((ui_gadget_h) parent_ug, UG_CONTACTS_LIST, UG_MODE_FULLVIEW, service, + &cbs); + service_destroy(service); + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", UG_CONTACTS_LIST); + } + return ug; +} + +ui_gadget_h phone_launch_contact_edit_ug(ui_gadget_h parent_ug, int data, + void (*destroy_cb)(void *), void *cb_param) +{ + PH_TRACE; + char buf[PH_TEXT_MAX_LEN] = { 0 }; + struct ug_cbs cbs = { 0 }; + service_h service; + + struct ug_priv_data *priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + + snprintf(buf, PH_TEXT_MAX_LEN, "%d", CT_UG_REQUEST_EDIT); + service_add_extra_data(service, CT_UG_BUNDLE_TYPE, buf); + snprintf(buf, PH_TEXT_MAX_LEN, "%d", data); + service_add_extra_data(service, CT_UG_BUNDLE_ID, buf); + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ui_gadget_h ug = ug_create((ui_gadget_h) parent_ug, UG_CONTACTS_DETAILS, UG_MODE_FULLVIEW, service, + &cbs); + service_destroy(service); + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", UG_CONTACTS_DETAILS); + } + return ug; +} + +ui_gadget_h phone_launch_bluetooth_ug(ui_gadget_h parent_ug, const char *attach, + void (*destroy_cb)(void *), void *cb_param) +{ + PH_TRACE; + service_h service; + struct ug_cbs cbs = { 0 }; + + struct ug_priv_data *priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + service_add_extra_data(service, LAUNCH_TYPE, SEND); + service_add_extra_data_array(service, FILES, &attach, FILECOUNT); + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ui_gadget_h ug = ug_create((ui_gadget_h) parent_ug, BLUETOOTH_UG, + UG_MODE_FULLVIEW, service, &cbs); + + service_destroy(service); + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", UG_CONTACTS_DETAILS); + } + return ug; +} + +static void ug_contact_list_result_cb(ui_gadget_h ug, service_h service, + void *priv) +{ + PH_TRACE; + char *temp_p = NULL; + struct ug_priv_data *priv_data = (ug_priv_data *) priv; + int id; + p_retm_if(NULL == priv, "private data is NULL"); + + service_get_extra_data(service, "id", &temp_p); + id = atoi(temp_p); + free(temp_p); + if (priv_data->result_cb) + priv_data->result_cb(priv_data->cb_param, (void*) &id); +} + +ui_gadget_h phone_launch_contact_list_ug(ui_gadget_h parent_ug, int request, + void (*result_cb)(void*, void*), void (*destroy_cb)(void*), + void*cb_param) +{ + PH_TRACE; + char ug_request[PH_TEXT_MAX_LEN] = { 0 }; + struct ug_priv_data *priv_data; + ui_gadget_h ug; + struct ug_cbs cbs = { 0 }; + service_h service; + + priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->result_cb = result_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + + snprintf(ug_request, sizeof(ug_request), "%d", request); + service_add_extra_data(service, CT_UG_BUNDLE_TYPE, ug_request); + + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.destroy_cb = ug_common_destroy_cb; + cbs.result_cb = ug_contact_list_result_cb; + + ug = ug_create((ui_gadget_h) parent_ug, UG_CONTACTS_LIST, UG_MODE_FULLVIEW, service, + &cbs); + service_destroy(service); + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", UG_CONTACTS_LIST); + } + return ug; +} + +Evas_Object* phone_create_list_sweep_btn(Evas_Object *parent, const char *fullpath) +{ + PH_TRACE; + Evas_Object *btn; + Evas_Object *icon; + + btn = elm_button_add(parent); + p_retvm_if(NULL == btn, NULL, "elm_button_add() return NULL"); + + icon = elm_icon_add(btn); + p_retvm_if(NULL == icon, NULL, "phone_create_icon_with_img() return NULL"); + + elm_image_file_set(icon, fullpath, NULL); + elm_image_resizable_set(icon, EINA_FALSE, EINA_FALSE); + elm_object_part_content_set(btn, "icon", icon); + + return btn; +} + +void phone_resize_notify(Evas_Object *parent, int rotate) +{ + PH_TRACE; + Evas_Object *notify; + Evas_Object *layout; + const char *msg; + p_retm_if(NULL == parent, "parent is NULL"); + notify = phone_get_notify(parent); + layout = elm_object_content_get(notify); + msg = edje_object_part_text_get(_EDJ(layout), "elm.text"); + + elm_layout_theme_set(layout, "standard", "selectioninfo", "center_text"); + + if (msg && *msg) + edje_object_part_text_set(_EDJ(layout), "elm.text", msg); +} + +Evas_Object * phone_get_notify(Evas_Object *parent) +{ + PH_TRACE; + Evas_Object *notify; + + notify = (Evas_Object *) evas_object_data_get(parent, "notify"); + if (NULL == notify) + { + Evas_Object *info_layout; + notify = phone_create_base_layout(parent, false); + elm_object_part_content_set(parent, "selectioninfo", notify); + info_layout = elm_layout_add(parent); + elm_object_part_content_set(notify, "elm.swallow.content", info_layout); + elm_layout_theme_set(info_layout, "standard", "selectioninfo", + "center_text"); + evas_object_data_set(parent, "notify", notify); + } + evas_object_show(notify); + return notify; +} + +void phone_show_tickernoti(const char *msg) +{ + PH_TRACE; + int err = notification_status_message_post(msg); + p_retm_if(NOTIFICATION_ERROR_NONE != err, + "notification_status_message_post is failed"); +} + +void phone_show_notify(Evas_Object *parent, const char *msg) +{ + PH_TRACE; + Evas_Object *selectioninfo; + Evas_Object *notify; + + notify = phone_get_notify(parent); + selectioninfo = elm_object_part_content_get(notify, "elm.swallow.content"); + elm_object_part_text_set(selectioninfo, "elm.text", msg); + elm_object_signal_emit(parent, "show,selection,info", "elm"); + evas_object_show(selectioninfo); +} + +void phone_hide_notify(Evas_Object *parent) +{ + PH_TRACE; + Evas_Object *selectioninfo; + Evas_Object *notify; + + notify = (Evas_Object *) evas_object_data_get(parent, "notify"); + selectioninfo = elm_object_part_content_get(notify, "elm.swallow.content"); + elm_object_signal_emit(parent, "hide,selection,info", "elm"); + evas_object_hide(notify); + evas_object_hide(selectioninfo); +} + +static void popup_cancel_btn_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + Evas_Object **popup = (Evas_Object **) data; + evas_object_del(*popup); + *popup = NULL; +} +void ctui_detail_data_popup_hide_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + ct_detail_data *cdetail_d = (ct_detail_data *) data; + if(cdetail_d && cdetail_d->popup) + { + evas_object_del(cdetail_d->popup); + cdetail_d->popup = NULL; + } +} + +void ctui_input_data_popup_hide_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + ct_input_data *cinput_d = (ct_input_data *) data; + if(cinput_d && cinput_d->popup) + { + evas_object_del(cinput_d->popup); + cinput_d->popup = NULL; + } +} + +Evas_Object *phone_show_popup(Evas_Object *parent, const char *desc, + double timeout) +{ + PH_TRACE; + Evas_Object *popup; + + popup = (Evas_Object *) evas_object_data_get(parent, "popup"); + if (NULL == popup) + { + popup = elm_popup_add(parent); + evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + evas_object_smart_callback_add(popup, "block,clicked", + ctui_input_data_popup_hide_cb, NULL); + evas_object_show(popup); + } + elm_object_text_set(popup, desc); + elm_popup_timeout_set(popup, timeout); + return popup; +} + +Evas_Object* phone_create_confirm_popup(Evas_Object **popup, Evas_Object *win, + const char* description, + void (*btn_clicked_cb)(void *, Evas_Object *, void *), void *cb_data) +{ + PH_TRACE; + Evas_Object *btn1, *btn2; + *popup = elm_popup_add(win); + evas_object_size_hint_weight_set(*popup, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + elm_object_text_set(*popup, description); + + btn1 = elm_button_add(*popup); + elm_object_text_set(btn1, S_(PH_SYS_SK_YES)); + elm_object_part_content_set(*popup, "button1", btn1); + elm_object_style_set(btn1, "popup_button/default"); + evas_object_smart_callback_add(btn1, "clicked", btn_clicked_cb, cb_data); + + btn2 = elm_button_add(*popup); + elm_object_text_set(btn2, S_(PH_SYS_SK_NO)); + elm_object_part_content_set(*popup, "button2", btn2); + elm_object_style_set(btn2, "popup_button/default"); + evas_object_smart_callback_add(btn2, "clicked", popup_cancel_btn_cb, + &(*popup)); + + evas_object_show(*popup); + + return btn1; +} + +void phone_launch_voice_call(const int person_id, const char* number) +{ + PH_TRACE; + char buf[PH_TEXT_MAX_LEN] = { 0 }; + service_h service; + int ret; + + ret = service_create(&service); + p_retm_if(SERVICE_ERROR_NONE != ret, "service_create() Failed(%d)", ret); + + service_set_operation(service, SERVICE_OPERATION_CALL); + snprintf(buf, sizeof(buf), "tel:%s", number); + service_set_uri(service, buf); + service_set_app_id(service, CALL_APP); + + if (0 < person_id) + { + char buf[PH_TEXT_MAX_LEN] = { 0 }; + snprintf(buf, sizeof(buf), "%d", person_id); + service_add_extra_data(service, "ctindex", buf); + + } + ret = service_send_launch_request(service, NULL, NULL); + if(ret != SERVICE_ERROR_NONE) + { + ERR("service_send_launch_request failed: %x", ret); + } + service_destroy(service); +} + +ui_gadget_h phone_launch_settings_ug(ui_gadget_h parent_ug, const char* ug_name, + void (*destroy_cb)(void*), void *cb_param) +{ + PH_TRACE; + ug_priv_data *priv_data = static_cast<ug_priv_data *>(calloc(1, sizeof(struct ug_priv_data))); + check_if(!priv_data, return NULL); + + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_h service; + int result = service_create(&service); + + if(SERVICE_ERROR_NONE != result) + { + free(priv_data); + ERR("service_create failed"); + return NULL; + } + + ug_cbs cbs = { 0 }; + cbs.priv = priv_data; + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + + ui_gadget_h ug = ug_create(parent_ug, ug_name, UG_MODE_FULLVIEW, service, &cbs); + + service_destroy(service); + + if (NULL == ug) + { + free(priv_data); + ERR("%s ug_create fail", CALL_SETTINGS_UG); + } + + return ug; +} + +Evas_Object* phone_create_base_layout(Evas_Object *parent, bool is_fullview) +{ + PH_TRACE; + Evas_Object *base; + + base = elm_layout_add(parent); + p_retvm_if(NULL == base, NULL, "elm_layout_add() Failed"); + if (is_fullview) + elm_layout_theme_set(base, "layout", "application", "default"); + else + elm_layout_theme_set(base, "layout", "application", "noindicator"); + evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + + return base; +} + +Evas_Object* phone_create_bg(Evas_Object *parent) +{ + PH_TRACE; + Evas_Object *bg; + + bg = elm_bg_add(parent); + p_retvm_if(NULL == bg, NULL, "elm_bg_add() return NULL"); + + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_object_part_content_set(parent, "elm.swallow.bg", bg); + + return bg; +} + +Evas_Object* phone_progressbar_popup(Evas_Object *parent, + ph_progress_info *p_info, const char *title) +{ + PH_TRACE; + Evas_Object *popup; + Evas_Object *layout; + Evas_Object *label; + Evas_Object *progressbar; + Evas_Object *btn; + + popup = elm_popup_add(parent); + p_retvm_if(NULL == popup, NULL, "elm_popup_add() return NULL"); + + layout = elm_layout_add(popup); + p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL"); + elm_layout_file_set(layout, PROGRESS_EDJ, "popup_center_text_progressview"); + evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + p_info->layout = layout; + + label = elm_label_add(popup); + p_retvm_if(NULL == label, NULL, "elm_label_add() return NULL"); + elm_object_style_set(label, "popup/progressview"); + elm_label_line_wrap_set(label, ELM_WRAP_MIXED); + elm_object_text_set(label, title); + evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0); + evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(label); + + progressbar = elm_progressbar_add(popup); + p_retvm_if(NULL == progressbar, NULL, "elm_progressbar_add() return NULL"); + p_info->progressbar = progressbar; + + if (0 < p_info->cnt_checked_total) + { + elm_object_style_set(progressbar, "list_progress"); + elm_progressbar_value_set(progressbar, 0.0); + } + else + { + elm_object_style_set(progressbar, "pending_list"); + elm_progressbar_pulse(progressbar, EINA_TRUE); + } + + evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, + EVAS_HINT_EXPAND); + evas_object_show(progressbar); + + elm_progressbar_horizontal_set(progressbar, EINA_TRUE); + elm_object_part_content_set(layout, "elm.swallow.content", label); + elm_object_part_content_set(layout, "elm.swallow.end", progressbar); + evas_object_show(layout); + elm_object_content_set(popup, layout); + + if (false == p_info->without_cancel_btn) + { + btn = elm_button_add(popup); + elm_object_text_set(btn, S_(PH_SYS_SK_CANCEL)); + elm_object_part_content_set(popup, "button1", btn); + elm_object_style_set(btn, "popup_button/default"); + evas_object_smart_callback_add(btn, "clicked", progress_popup_cancel_cb, + &p_info->alive); + } + evas_object_show(popup); + return popup; +} + +void phone_navi_item_reset(Elm_Object_Item *item, void *data) +{ + PH_TRACE; + assert(item); + Common::View *view = static_cast<Common::View *>(data); + + if (item && view) + { + elm_object_item_data_set(item, view); + view->back_cb = NULL; + view->menu_cb = NULL; + } +} + +Evas_Object *phone_create_icon_with_img(Evas_Object *parent, const char *full_path) +{ + PH_TRACE; + Evas_Object *ic = elm_icon_add(parent); + p_retvm_if(NULL == ic, NULL, "elm_icon_add() return NULL"); + elm_image_file_set(ic, full_path, NULL); + elm_image_resizable_set(ic, EINA_TRUE, EINA_TRUE); + evas_object_image_smooth_scale_set(ic, EINA_FALSE); + return ic; +} + +contacts_error_e phone_cts_get_list(const char *view_uri, int property_id, + int match_value, contacts_list_h *out_list) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_filter_h filter = NULL; + contacts_query_h query = NULL; + + p_retvm_if(NULL == out_list, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(out_list) is NULL"); + + unsigned int person_grouprel_projection[] = { + _contacts_person_grouprel.person_id, + _contacts_person_grouprel.status, + _contacts_person_grouprel.display_name, + _contacts_person_grouprel.display_name_index, + _contacts_person_grouprel.addressbook_ids, + _contacts_person_grouprel.image_thumbnail_path, + _contacts_person_grouprel.link_count, }; + + err = (contacts_error_e) contacts_filter_create(view_uri, &filter); + p_retvm_if(CONTACTS_ERROR_NONE != err, err, + "contactcs_filter_create() Failed(%d)", err); + + do + { + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_int(filter, property_id, + CONTACTS_MATCH_EQUAL, match_value))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_query_create(view_uri, &query))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_query_set_filter(query, filter))) + break; + + if (0 == strcmp(view_uri, _contacts_person_grouprel._uri)) + { + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_query_set_distinct(query, true))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_query_set_projection(query, + person_grouprel_projection, + sizeof(person_grouprel_projection) / sizeof(int)))) + break; + } + + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_db_get_records_with_query(query, 0, 0, + out_list))) + break; + + contacts_filter_destroy(filter); + contacts_query_destroy(query); + + return CONTACTS_ERROR_NONE; + } + while (0); + p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_create() Failed(%d)", + err); + + contacts_filter_destroy(filter); + contacts_query_destroy(query); + + return err; +} + +void phone_cts_free_list(contacts_list_h list) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + err = (contacts_error_e) contacts_list_destroy(list, true); + p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_destroy() Failed(%d)", + err); +} + +contacts_error_e phone_cts_get_int_from_list(contacts_list_h list, + int property_id, int *out_int) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + p_retvm_if(NULL == out_int, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(out_int) is NULL"); + p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(list) is NULL"); + + err = (contacts_error_e) contacts_list_get_current_record_p(list, &record); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + return err; + } + + err = (contacts_error_e) contacts_record_get_int(record, property_id, out_int); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_int() Failed(%d)", err); + return err; + } + + return CONTACTS_ERROR_NONE; +} + +contacts_error_e phone_cts_get_str_from_list(contacts_list_h list, + int property_id, char **out_str) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + p_retvm_if(NULL == out_str, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(out_int) is NULL"); + p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(list) is NULL"); + + err = (contacts_error_e) contacts_list_get_current_record_p(list, &record); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + return err; + } + + err = (contacts_error_e) contacts_record_get_str(record, property_id, out_str); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_str() Failed(%d)", err); + return err; + } + + return CONTACTS_ERROR_NONE; +} + +contacts_error_e phone_cts_get_bool_from_list(contacts_list_h list, + int property_id, bool *out_bool) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + p_retvm_if(NULL == out_bool, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(out_bool) is NULL"); + p_retvm_if(NULL == list, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(list) is NULL"); + + err = (contacts_error_e) contacts_list_get_current_record_p(list, &record); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + return err; + } + + err = (contacts_error_e) contacts_record_get_bool(record, property_id, out_bool); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_bool() Failed(%d)", err); + return err; + } + + return CONTACTS_ERROR_NONE; +} + +char* ctui_get_addressbook_icon_path(int addressbook_id) +{ + PH_TRACE; + int ret; + int account_id; + char *icon_path; + char *addressbook_name = NULL; + account_h account; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + err = (contacts_error_e) contacts_db_get_record(_contacts_address_book._uri, addressbook_id, + &record); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, + "phone_cts_get_list() Failed(%d)", err); + + err = (contacts_error_e) contacts_record_get_int(record, _contacts_address_book.account_id, + &account_id); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_int() Failed(%d)", err); + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + return NULL; + } + err = (contacts_error_e) contacts_record_get_str_p(record, _contacts_address_book.name, + &addressbook_name); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_int() Failed(%d)", err); + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + return NULL; + } + + if (0 == account_id) + { + return SAFE_STRDUP(CTUI_IMG_ACC_PHONE); + } + + ret = account_connect(); + p_retvm_if(ACCOUNT_ERROR_NONE != ret, NULL, "account_connect() Failed(%d)", + ret); + + account = NULL; + ret = account_create(&account); + p_retvm_if(ACCOUNT_ERROR_NONE != ret, false, "account_create() Failed(%d)", + ret); + + ret = account_query_account_by_account_id(account_id, &account); + if (ACCOUNT_ERROR_NONE != ret) + { + ERR("account_query_account_by_account_id() Failed(%d)", ret); + account_destroy(account); + account_disconnect(); + return NULL; + } + p_retvm_if(ACCOUNT_ERROR_NONE != ret, NULL, + "account_query_account_by_account_id() Failed(%d)", ret); + + ret = account_get_icon_path(account, &icon_path); + if (ACCOUNT_ERROR_NONE != ret) + { + ERR("account_get_icon_path() Failed(%d)", ret); + account_destroy(account); + account_disconnect(); + return NULL; + } + account_destroy(account); + account_disconnect(); + + return icon_path; +} + +Evas_Object* phone_create_navi_btn(Evas_Object *parent, const char *style) +{ + PH_TRACE; + Evas_Object *btn; + + btn = elm_button_add(parent); + elm_object_style_set(btn, style); + evas_object_show(btn); + + return btn; +} + +void phone_set_view_info(ph_view_info *view_info, Evas_Object *win, + Evas_Object *navi, void *ug, int ug_request, int cnt_max, char *ug_data) +{ + PH_TRACE; + view_info->win = win; + view_info->navi = navi; + view_info->ug = (ui_gadget_h) ug; + view_info->ug_request = ug_request; + view_info->ug_cnt_max = cnt_max; + view_info->ug_data = ug_data; +} + +void phone_list_ug_return_ids(ui_gadget_h ug, int *result_list, int cnt, + const char *bd_key) +{ + PH_TRACE; + gchar *encoded_str; + service_h service; + + service_create(&service); + + if (result_list) + { + encoded_str = g_base64_encode((guchar *) result_list, + cnt * sizeof(int)); + service_add_extra_data(service, bd_key, encoded_str); + g_free(encoded_str); + } + + ug_send_result(ug, service); + + service_destroy(service); +} + +void phone_list_ug_return_values(service_h service, int *result_list, int cnt, + const char *result_type) +{ + PH_TRACE; + service_h reply; + int ct_ret; + int i = 0, j = 0; + char **result_array = NULL; + service_result_e result = SERVICE_RESULT_SUCCEEDED; + + p_retm_if(result_list == NULL || cnt < 1 || result_type == NULL, + "invalid input param"); + + service_create(&reply); + result_array = (char **) calloc(cnt, sizeof(char *)); + + if (strcmp(CT_OPERATION_RESULT_TYPE_PHONE, result_type) == 0) + { + for (i = 0; i < cnt; i++) + { + contacts_record_h number_record = NULL; + char *number = NULL; + ct_ret = contacts_db_get_record(_contacts_number._uri, + result_list[i], &number_record); + if (ct_ret != CONTACTS_ERROR_NONE) + { + ERR("contacts_db_get_record number failed id %d", + result_list[i]); + continue; + } + + contacts_record_get_str_p(number_record, _contacts_number.number, + &number); + result_array[i] = strdup(number); + PH_DBG("number %s", result_array[i]); + contacts_record_destroy(number_record, TRUE); + } + + service_add_extra_data_array(reply, CT_OPERATION_PHONE, + (const char **) result_array, cnt); + } + else if (strcmp(CT_OPERATION_RESULT_TYPE_EMAIL, result_type) == 0) + { + for (i = 0; i < cnt; i++) + { + contacts_record_h email_record = NULL; + char *email = NULL; + ct_ret = contacts_db_get_record(_contacts_email._uri, + result_list[i], &email_record); + if (ct_ret != CONTACTS_ERROR_NONE) + { + ERR("contacts_db_get_record email faile id %d", result_list[i]); + continue; + } + + contacts_record_get_str_p(email_record, _contacts_email.email, + &email); + result_array[i] = strdup(email); + PH_DBG("email %s", result_array[i]); + contacts_record_destroy(email_record, TRUE); + } + + service_add_extra_data_array(reply, CT_OPERATION_EMAIL, + (const char **) result_array, cnt); + + } + else if (strcmp(CT_OPERATION_RESULT_TYPE_ITEM_ID, result_type) == 0) + { + for (i = 0; i < cnt; i++) + { + char buf[4]; + snprintf(buf, sizeof(buf), "%d", result_list[i]); + result_array[i] = strdup(buf); + PH_DBG("person id %s", result_array[i]); + } + + service_add_extra_data_array(reply, CT_OPERATION_ITEM_ID, + (const char **) result_array, cnt); + + } + else + { + ERR("wrong result type %s", result_type); + result = SERVICE_RESULT_FAILED; + } + + service_reply_to_launch_request(reply, service, result); + service_destroy(reply); + + for (j = 0; j < i; j++) + { + free(result_array[j]); + } + free(result_array); +} + +void phone_service_reply_simple(service_h service, service_result_e result) +{ + PH_TRACE; + service_h reply; + service_create(&reply); + service_reply_to_launch_request(reply, service, result); + service_destroy(reply); +} + +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) +{ + PH_TRACE; + gchar *encoded_str; + service_h service; + service_create(&service); + + if (result_number_list && number_list_count) + { + encoded_str = g_base64_encode((guchar *) result_number_list, + number_list_count * sizeof(int)); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_NUMBER_ID_LIST, + encoded_str); + g_free(encoded_str); + } + + if (result_email_list && email_list_count) + { + encoded_str = g_base64_encode((guchar *) result_email_list, + email_list_count * sizeof(int)); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_EMAIL_ID_LIST, + encoded_str); + g_free(encoded_str); + } + + ug_send_result(ug, service); + service_destroy(service); +} + +#define CT_UG_BUNDLE_RESULT_ID "id" +#define CT_UG_BUNDLE_RESULT_VCARD "vcard" + +void phone_ug_return_id(ui_gadget_h ug, int ct_id, int num_id, int email_id) +{ + PH_TRACE; + service_h service; + char buf[16]; + + service_create(&service); + + if (ct_id) + { + snprintf(buf, sizeof(buf), "%d", ct_id); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_PERSON_ID, buf); + } + + if (num_id) + { + snprintf(buf, sizeof(buf), "%d", num_id); + service_remove_extra_data(service, CT_UG_BUNDLE_RESULT_ID); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_NUMBER_ID, buf); + } + + if (email_id) + { + snprintf(buf, sizeof(buf), "%d", email_id); + service_remove_extra_data(service, CT_UG_BUNDLE_RESULT_ID); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_EMAIL_ID, buf); + } + + PH_DBG("ct_id =%d, num_id=%d,email_id=%d", ct_id, num_id, email_id); + ug_send_result(ug, service); + + service_destroy(service); +} + +void phone_ug_return_value(service_h service, int person_id, int num_id, + int email_id, int result_id) +{ + PH_TRACE; + service_h reply; + char buf[16]; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h number_record = NULL; + contacts_record_h email_record = NULL; + + service_create(&reply); + + if (person_id) + { + char **result_array = NULL; + result_array = (char **) calloc(1, sizeof(char *)); + + snprintf(buf, sizeof(buf), "%d", person_id); + PH_DBG("person id %s", buf); + + result_array[0] = strdup(buf); + service_add_extra_data_array(reply, CT_OPERATION_ITEM_ID, + (const char **) result_array, 1); + + service_reply_to_launch_request(reply, service, + SERVICE_RESULT_SUCCEEDED); + + service_destroy(reply); + + free(result_array[0]); + free(result_array); + + return; + } + + if (num_id) + { + const char *number = NULL; + char **result_array = NULL; + result_array = (char **) calloc(1, sizeof(char *)); + + err = (contacts_error_e) contacts_db_get_record(_contacts_number._uri, num_id, + &number_record); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_db_get_record() Failed(%d)", err); + + err = (contacts_error_e) contacts_record_get_str_p(number_record, _contacts_number.number, + (char**) &number); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_get_str_p() Failed(%d)", err); + + PH_DBG("number=%d", number); + + result_array[0] = strdup(number); + service_add_extra_data_array(reply, CT_OPERATION_RESULT_TYPE_PHONE, + (const char **) result_array, 1); + + service_reply_to_launch_request(reply, service, + SERVICE_RESULT_SUCCEEDED); + + err = (contacts_error_e) contacts_record_destroy(number_record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + + service_destroy(reply); + + free(result_array[0]); + free(result_array); + + return; + } + + if (email_id) + { + const char *email = NULL; + char **result_array = NULL; + result_array = (char **) calloc(1, sizeof(char *)); + + err = (contacts_error_e) contacts_db_get_record(_contacts_email._uri, email_id, + &email_record); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_db_get_record() Failed(%d)", err); + + err = (contacts_error_e) contacts_record_get_str_p(email_record, _contacts_email.email, + (char**) &email); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_get_str_p() Failed(%d)", err); + + PH_DBG("email=%d", email); + + result_array[0] = strdup(email); + service_add_extra_data_array(reply, CT_OPERATION_RESULT_TYPE_EMAIL, + (const char **) result_array, 1); + + service_reply_to_launch_request(reply, service, + SERVICE_RESULT_SUCCEEDED); + + err = (contacts_error_e) contacts_record_destroy(email_record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + + service_destroy(reply); + + free(result_array[0]); + free(result_array); + + return; + } + + if (result_id) + { + snprintf(buf, sizeof(buf), "%d", person_id); + PH_DBG("person id %s", buf); + + service_add_extra_data(reply, CT_OPERATION_ITEM_ID, buf); + + service_reply_to_launch_request(reply, service, + SERVICE_RESULT_SUCCEEDED); + + service_destroy(reply); + + return; + } + +} + +void phone_ug_operation_return_vcard(service_h service, int ct_id, char *vcard) +{ + PH_TRACE; + service_h reply; + + service_create(&reply); + + if (vcard) + { + service_add_extra_data(reply, CT_OPERATION_PATH, vcard); + } + + service_reply_to_launch_request(reply, service, SERVICE_RESULT_SUCCEEDED); + + service_destroy(reply); +} + +void phone_ug_return_vcard(ui_gadget_h ug, int ct_id, char *vcard) +{ + PH_TRACE; + service_h service; + char buf[16]; + + service_create(&service); + + if (ct_id) + { + snprintf(buf, sizeof(buf), "%d", ct_id); + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_ID, buf); + } + + if (vcard) + { + service_add_extra_data(service, CT_UG_BUNDLE_RESULT_VCARD, vcard); + } + + ug_send_result(ug, service); + + service_destroy(service); +} + +static void editfield_exceed_string_cb(void *data, Evas_Object *obj, + void *event_info) +{ + PH_TRACE; + phone_show_tickernoti(T_(CT_GET_TEXT_ERR, CTTEXT_EXCEED_LIMIT)); +} + +static void editfield_changed_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + if (!elm_entry_is_empty(obj)) + elm_object_signal_emit((Evas_Object *) data, "elm,state,guidetext,hide", "elm"); + + if (elm_object_focus_get((Evas_Object *) data)) + { + if (elm_entry_is_empty(obj)) + elm_object_signal_emit((Evas_Object *) data, "elm,state,eraser,hide", "elm"); + else + elm_object_signal_emit((Evas_Object *) data, "elm,state,eraser,show", "elm"); + } +} +static void editfield_focused_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + if (!elm_entry_is_empty(obj)) + elm_object_signal_emit((Evas_Object *) data, "elm,state,eraser,show", "elm"); + elm_object_signal_emit((Evas_Object *) data, "elm,state,guidetext,hide", "elm"); +} + +static void editfield_unfocused_cb(void *data, Evas_Object *obj, + void *event_info) +{ + PH_TRACE; + if (elm_entry_is_empty(obj)) + elm_object_signal_emit((Evas_Object *) data, "elm,state,guidetext,show", "elm"); + elm_object_signal_emit((Evas_Object *) data, "elm,state,eraser,hide", "elm"); +} + +static void editfield_eraser_clicked_cb(void *data, Evas_Object *obj, + const char *emission, const char *source) +{ + PH_TRACE; + elm_entry_entry_set((Evas_Object *) data, ""); +} + +Evas_Object* ctui_create_editfield(Evas_Object *parent, const char *title, + const char *guide, bool multiline) +{ + PH_TRACE; + Evas_Object *layout, *entry; + + layout = elm_layout_add(parent); + if (title && *title) + { + elm_layout_theme_set(layout, "layout", "editfield", "title"); + elm_object_part_text_set(layout, "elm.text", title); + } + else + elm_layout_theme_set(layout, "layout", "editfield", "default"); + + if (guide && *guide) + elm_object_part_text_set(layout, "elm.guidetext", guide); + + entry = elm_entry_add(parent); + if (!multiline) + { + elm_entry_scrollable_set(entry, EINA_TRUE); + elm_entry_single_line_set(entry, EINA_TRUE); + } + ctui_entry_limit_size_set(entry); + elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT); + elm_entry_input_panel_layout_set(entry, ELM_INPUT_PANEL_LAYOUT_NORMAL); + evas_object_smart_callback_add(entry, "changed", editfield_changed_cb, + layout); + evas_object_smart_callback_add(entry, "preedit,changed", + editfield_changed_cb, layout); + evas_object_smart_callback_add(entry, "focused", editfield_focused_cb, + layout); + evas_object_smart_callback_add(entry, "unfocused", editfield_unfocused_cb, + layout); + evas_object_smart_callback_add(entry, "maxlength,reached", + editfield_exceed_string_cb, layout); + elm_object_part_content_set(layout, "elm.swallow.content", entry); + elm_object_signal_callback_add(layout, "elm,eraser,clicked", "elm", + editfield_eraser_clicked_cb, entry); + return layout; +} + +// This function is used in Contact view, Group view +ui_gadget_h ctui_account_ug(void *data, Evas_Object *obj, void *event_info, + void (*destroy_cb)(void*), void *cb_param) +{ + PH_TRACE; + struct ug_cbs cbs = { 0 }; + ui_gadget_h ug; + service_h service; + struct ug_priv_data *priv_data; + + priv_data = (ug_priv_data *) calloc(1, sizeof(struct ug_priv_data)); + p_retvm_if(NULL == priv_data, NULL, "calloc is failed"); + priv_data->destroy_cb = destroy_cb; + priv_data->cb_param = cb_param; + + service_create(&service); + service_add_extra_data(service, "mode", "account_list"); + service_add_extra_data(service, "capability_filter", + ACCOUNT_SUPPORTS_CAPABILITY_CONTACT); + + cbs.layout_cb = ug_common_layout_cb; + cbs.result_cb = NULL; + cbs.destroy_cb = ug_common_destroy_cb; + cbs.priv = priv_data; + + ug = ug_create((ui_gadget_h) data, ACCOUNT_UG, UG_MODE_FULLVIEW, service, &cbs); + p_warn_if(NULL == ug, "ug_create() Failed"); + + service_destroy(service); + return ug; +} + +Evas_Object* phone_create_nocontents(Evas_Object *parent, const char* label) +{ + PH_TRACE; + Evas_Object *layout; + + layout = elm_layout_add(parent); + p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL"); + + elm_layout_theme_set(layout, "layout", "nocontents", "full"); + elm_object_part_text_set(layout, "elm.text", label); + + return layout; +} + +void ctui_genlist_append_separator_20px_with_line(Evas_Object *genlist) +{ + PH_TRACE; + static Elm_Genlist_Item_Class itc; + itc.item_style = "dialogue/separator/21/with_line"; + + Elm_Object_Item *item; + item = elm_genlist_item_append(genlist, &itc, NULL, NULL, + ELM_GENLIST_ITEM_NONE, NULL, NULL); + elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY); +} + +void ctui_genlist_append_separator_8px_with_line(Evas_Object *genlist) +{ + static Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new(); + itc->item_style = "dialogue/separator/2"; + elm_genlist_item_append(genlist, itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); +} + +void phone_toolbar_disabled_item_append(Evas_Object *toolbar, int cnt) +{ + PH_TRACE; + int i; + Elm_Object_Item * item; + for (i = 0; i < cnt; i++) + { + item = elm_toolbar_item_append(toolbar, NULL, NULL, NULL, NULL); + elm_object_item_disabled_set(item, EINA_TRUE); + } +} + +int ctui_get_mfc_option(void) +{ + PH_TRACE; + int fd; + int size; + char buf[PH_TEXT_SHORT_LEN]; + + fd = open(SETTING_MFC_PATH, O_RDONLY); + if (fd < 0) + { + ERR("Open(%s) O_RDONLY Failed", SETTING_MFC_PATH); + fd = open(SETTING_MFC_PATH, O_WRONLY | O_CREAT | O_TRUNC, 0644); + p_retvm_if(fd < 0, 0, "Open(%s) Failed", SETTING_MFC_PATH); + if (-1 == write(fd, "0", 1)) + ERR("write()... Failed(%s)", strerror(errno)); + } + size = read(fd, buf, sizeof(buf)); + close(fd); + if (0 < size) + return atoi(buf); + else + return 0; +} + +static void genlist_selectall_mouseup_cb(void *data, Evas *e, Evas_Object *obj, + void *event_info) +{ + PH_TRACE; + int x, y, w, h; + Eina_Bool is_checked; + Evas_Object *check; + Evas_Event_Mouse_Up *ev = (Evas_Event_Mouse_Up *) event_info; + void *cb_data; + selectall_changed_cb changed_cb = (selectall_changed_cb) data; + + if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) + return; + + evas_object_geometry_get(obj, &x, &y, &w, &h); + if (ev->output.y < y || y + h < ev->output.y) + return; + + p_retm_if(NULL == changed_cb, "changed_cb is NULL"); + + check = elm_object_part_content_get(obj, "elm.icon"); + p_retm_if(NULL == check, "elm_object_part_content_get() return NULL"); + + cb_data = evas_object_data_get(check, "cb_data"); + p_retm_if(NULL == cb_data, "cb_data is NULL"); + + is_checked = !elm_check_state_get(check); + elm_check_state_set(check, is_checked); + + changed_cb(cb_data, is_checked); +} + +static void genlist_selectall_changed_cb(void *data, Evas_Object *obj, + void *event_info) +{ + PH_TRACE; + Eina_Bool is_checked; + void *cb_data; + selectall_changed_cb changed_cb = (selectall_changed_cb) data; + p_retm_if(NULL == changed_cb, "changed_cb is NULL"); + + cb_data = evas_object_data_get(obj, "cb_data"); + p_retm_if(NULL == cb_data, "cb_data is NULL"); + + is_checked = elm_check_state_get(obj); + changed_cb(cb_data, is_checked); +} + +Evas_Object* phone_create_select_all(Evas_Object *parent, + const char *selectall_text, selectall_changed_cb changed_cb, + void *cb_data) +{ + PH_TRACE; + Evas_Object *layout; + Evas_Object *check; + + p_retvm_if(NULL == parent, NULL, "parameter(parent) is NULL"); + + layout = elm_layout_add(parent); + p_retvm_if(NULL == layout, NULL, "elm_layout_add() return NULL"); + elm_layout_theme_set(layout, "genlist", "item", "select_all/default"); + evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, 0); + evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_event_callback_add(layout, EVAS_CALLBACK_MOUSE_UP, + genlist_selectall_mouseup_cb, (const void *) changed_cb); + + check = elm_check_add(layout); + p_retvm_if(NULL == check, NULL, "elm_check_add() return NULL"); + evas_object_propagate_events_set(check, EINA_FALSE); + elm_object_part_content_set(layout, "elm.icon", check); + evas_object_smart_callback_add(check, "changed", + genlist_selectall_changed_cb, (const void *) changed_cb); + evas_object_data_set(check, "cb_data", cb_data); + + elm_object_part_text_set(layout, "elm.text", selectall_text); + evas_object_show(layout); + + return layout; +} + +void phone_move_ctxpopup(Evas_Object *popup, Evas_Object *item) +{ + PH_TRACE; + int x, y, w, h; + int pos_x; + int pos_y; + p_retm_if(NULL == popup, "parameter(popup) is NULL"); + p_retm_if(NULL == item, "parameter(item) is NULL"); + + evas_object_geometry_get(item, &x, &y, &w, &h); + + pos_x = x + (Evas_Coord) w / 2; + pos_y = y + (Evas_Coord) h / 2; + + evas_object_move(popup, pos_x, pos_y); +} + +void ctui_get_addressbook_name(int addressbook_id, char *dest, int dest_len) +{ + PH_TRACE; + char *display_name = NULL; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + p_retm_if(NULL == dest, "parameter(dest) is NULL"); + dest[0] = '\0'; + + if (addressbook_id <= 0) + { + snprintf(dest, dest_len, "%s", T_(CT_GET_TEXT_BASIC, CTTEXT_PHONE)); + return; + } + + err = (contacts_error_e) contacts_db_get_record(_contacts_address_book._uri, + addressbook_id, &record); + p_retm_if(CONTACTS_ERROR_NONE != err, "contacts_db_get_record() Failed(%d)", + err); + + err = (contacts_error_e) contacts_record_get_str_p(record, + _contacts_address_book.name, &display_name); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_get_str_p() Failed(%d)", err); + + if (display_name && *display_name) + snprintf(dest, dest_len, "%s", display_name); + + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); +} + +void ctui_get_account_name_by_address_book_id(int address_book_id, char *dest, + int dest_len) +{ + PH_TRACE; + int ret; + int account_id; + char *domain_name; + account_h account; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + + err = (contacts_error_e) contacts_db_get_record(_contacts_address_book._uri, + address_book_id, &record); + p_retm_if(CONTACTS_ERROR_NONE != err, "phone_cts_get_list() Failed(%d)", + err); + + err = (contacts_error_e) contacts_record_get_int(record, + _contacts_address_book.account_id, &account_id); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_get_int() Failed(%d)", err); + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + return; + } + + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + + if (0 == account_id) + return; + + ret = account_connect(); + p_retm_if(ACCOUNT_ERROR_NONE != ret, "account_connect() Failed(%d)", ret); + + account = NULL; + ret = account_create(&account); + if (ACCOUNT_ERROR_NONE != ret) + { + ERR("account_create() Failed(%d)", ret); + account_disconnect(); + return; + } + + ret = account_query_account_by_account_id(account_id, &account); + if (ACCOUNT_ERROR_NONE != ret) + { + ERR("account_query_account_by_account_id() Failed(%d)", ret); + account_destroy(account); + account_disconnect(); + return; + } + + ret = account_get_domain_name(account, &domain_name); + if (ACCOUNT_ERROR_NONE != ret) + { + ERR("account_get_display_name() Failed(%d)", ret); + account_destroy(account); + account_disconnect(); + return; + } + PH_DBG("domain_name = %s", domain_name); + + account_destroy(account); + account_disconnect(); + + if (domain_name && *domain_name) + snprintf(dest, dest_len, "%s", domain_name); + + free(domain_name); +} + +// TODO: Fixme +Eina_List* ctui_person_get_writable_contact_list(int person_id) +{ + PH_TRACE; + int addressbook_id; + int addressbook_mode; + Eina_List *list_contact_record = NULL; + + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_list_h list_contact = NULL; + contacts_record_h record_addressbook = NULL; + contacts_record_h record_contact = NULL; + contacts_record_h record_contact_clone = NULL; + + p_retvm_if(person_id <= 0, NULL, "Invalid parameter(%d)", person_id); + + err = phone_cts_get_list(_contacts_contact._uri, + _contacts_contact.person_id, person_id, &list_contact); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, + "phone_cts_get_list() Failed(%d)", err); + + while (CONTACTS_ERROR_NONE == err) + { + err = phone_cts_get_int_from_list(list_contact, + _contacts_contact.address_book_id, &addressbook_id); + if (CONTACTS_ERROR_NONE != err) + { + ERR("phone_cts_get_int_from_list() Failed(%d)", err); + break; + } + + err = (contacts_error_e) contacts_db_get_record( + _contacts_address_book._uri, addressbook_id, + &record_addressbook); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_db_get_record() Failed(%d)", err); + break; + } + + err = (contacts_error_e) contacts_record_get_int(record_addressbook, + _contacts_address_book.mode, &addressbook_mode); + if (CONTACTS_ERROR_NONE != err) + { + ERR("phone_cts_get_int_from_list() Failed(%d)", err); + err = (contacts_error_e) contacts_record_destroy(record_addressbook, + true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + break; + } + + err = (contacts_error_e) contacts_record_destroy(record_addressbook, + true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + + if (CONTACTS_ADDRESS_BOOK_MODE_READONLY == addressbook_mode) + { + err = (contacts_error_e) contacts_list_next(list_contact); + continue; + } + + err = (contacts_error_e) contacts_list_get_current_record_p( + list_contact, &record_contact); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + break; + } + + err = (contacts_error_e) contacts_record_clone(record_contact, + &record_contact_clone); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_clone() Failed(%d)", err); + break; + } + + list_contact_record = eina_list_append(list_contact_record, + record_contact_clone); + + err = (contacts_error_e) contacts_list_next(list_contact); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_next() Failed(%d)", err); + break; + } + } + phone_cts_free_list(list_contact); + + return list_contact_record; +} + +static bool __phone_list_is_email_exist(Eina_List *list, char *email_address) +{ + PH_TRACE; + Eina_List *l; + char *email_address_temp; + contacts_error_e err = CONTACTS_ERROR_NONE; + void *v_record_temp = NULL; + + EINA_LIST_FOREACH(list, l, v_record_temp) + { + contacts_record_h record_temp = (contacts_record_h) v_record_temp; + if (NULL == record_temp) + continue; + + err = (contacts_error_e) contacts_record_get_str_p(record_temp, + _contacts_email.email, &email_address_temp); + p_retvm_if(CONTACTS_ERROR_NONE != err, false, + "contacts_record_get_str_p() Failed(%d)", err); + + if (NULL == email_address_temp) + continue; + + if (0 == strcmp(email_address_temp, email_address)) + return true; + } + return false; +} + +Eina_List* ctui_person_get_email_list(Eina_List *contact_list) +{ + PH_TRACE; + Eina_Bool checkduplicate = false; + int index = 0; + char *email_address; + Eina_List *l; + Eina_List *list_email_record = NULL; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record_email = NULL; + contacts_record_h record_clone = NULL; + void *v_record = NULL; + + EINA_LIST_FOREACH(contact_list, l, v_record) + { + contacts_record_h record = (contacts_record_h) v_record; + index = 0; + while (CONTACTS_ERROR_NONE + == contacts_record_get_child_record_at_p(record, + _contacts_contact.email, index++, &record_email)) + { + err = (contacts_error_e) contacts_record_get_str_p(record_email, + _contacts_email.email, &email_address); + if (CONTACTS_ERROR_NONE != err) + { + ERR("phone_cts_get_str_from_list() Failed(%d)", err); + break; + } + if (checkduplicate) + { + if (__phone_list_is_email_exist(list_email_record, + email_address)) + { + ERR( + "__phone_list_is_email_exist() return true (email address = %s", + email_address); + continue; + } + } + err = (contacts_error_e) contacts_record_clone(record_email, + &record_clone); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + break; + } + list_email_record = eina_list_append(list_email_record, + record_clone); + } + checkduplicate = true; + } + return list_email_record; +} + +static bool __phone_list_is_number_exist(Eina_List *list, char *number_str) +{ + PH_TRACE; + Eina_List *l; + char *number_str_temp; + contacts_error_e err = CONTACTS_ERROR_NONE; + void *v_record_temp = NULL; + + EINA_LIST_FOREACH(list, l, v_record_temp) + { + contacts_record_h record_temp = (contacts_record_h) v_record_temp; + if (NULL == record_temp) + continue; + + err = (contacts_error_e) contacts_record_get_str_p(record_temp, + _contacts_number.number, &number_str_temp); + p_retvm_if(CONTACTS_ERROR_NONE != err, false, + "contacts_record_get_str_p() Failed(%d)", err); + + if (NULL == number_str_temp) + continue; + + if (0 == strcmp(number_str_temp, number_str)) + return true; + } + return false; +} + +Eina_List* ctui_person_get_number_list(Eina_List *contact_list) +{ + PH_TRACE; + Eina_Bool checkduplicate = false; + int index = 0; + char *number_str; + Eina_List *l; + Eina_List *list_number_record = NULL; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record_number = NULL; + contacts_record_h record_clone = NULL; + void *v_record = NULL; + + EINA_LIST_FOREACH(contact_list, l, v_record) + { + contacts_record_h record = (contacts_record_h) v_record; + index = 0; + while (CONTACTS_ERROR_NONE + == contacts_record_get_child_record_at_p(record, + _contacts_contact.number, index++, &record_number)) + { + err = (contacts_error_e) contacts_record_get_str_p(record_number, + _contacts_number.number, &number_str); + if (CONTACTS_ERROR_NONE != err) + { + ERR("phone_cts_get_str_from_list() Failed(%d)", err); + break; + } + if (checkduplicate) + { + if (__phone_list_is_number_exist(list_number_record, + number_str)) + { + ERR( + "__phone_list_is_number_exist() return true (number = %s", + number_str); + continue; + } + } + err = (contacts_error_e) contacts_record_clone(record_number, + &record_clone); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + break; + } + list_number_record = eina_list_append(list_number_record, + record_clone); + } + checkduplicate = true; + } + return list_number_record; +} + +Eina_List* ctui_person_get_contact_list(int person_id) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record_contact = NULL; + contacts_record_h record_contact_clone = NULL; + contacts_list_h list_contacts = NULL; + Eina_List *list_contact_records = NULL; + + err = phone_cts_get_list(_contacts_contact._uri, + _contacts_contact.person_id, person_id, &list_contacts); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, + "phone_cts_get_list() Failed(%d)", err); + + while (err == CONTACTS_ERROR_NONE) + { + err = (contacts_error_e) contacts_list_get_current_record_p( + list_contacts, &record_contact); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_list_get_current_record_p() Failed(%d)", err); + break; + } + + err = (contacts_error_e) contacts_record_clone(record_contact, + &record_contact_clone); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_clone() Failed(%d)", err); + break; + } + + list_contact_records = eina_list_append(list_contact_records, + record_contact_clone); + + err = (contacts_error_e) contacts_list_next(list_contacts); + p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_list_next() Failed(%d)", + err); + } + phone_cts_free_list(list_contacts); + + return list_contact_records; +} + +void ctui_free_record_list(Eina_List *contact_list) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + void *v_record = NULL; + p_retm_if(NULL == contact_list, "contact_list is NULL"); + + EINA_LIST_FREE(contact_list, v_record) + { + contacts_record_h record = (contacts_record_h) v_record; + if (NULL == record) + continue; + err = (contacts_error_e) contacts_record_destroy(record, true); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_record_destroy() Failed(%d)", err); + continue; + } + } +} + +// TODO: Fixme +int ctui_get_email_type_index(int type) +{ + PH_TRACE; + switch (type) + { + case CONTACTS_EMAIL_TYPE_CUSTOM: + return 1; + case CONTACTS_EMAIL_TYPE_HOME: + return 2; + case CONTACTS_EMAIL_TYPE_WORK: + return 3; + default: + return 0; + } +} + +int ctui_get_view_mode(void) +{ + PH_TRACE; + int fd; + int size; + char buf[PH_TEXT_SHORT_LEN]; + + fd = open(VIEW_MODE_PATH, O_RDONLY); + if (fd < 0) + { + ctui_set_view_mode(-1); + PH_DBG("Open(%s) Failed so create new", VIEW_MODE_PATH); + return -1; + } + size = read(fd, buf, sizeof(buf)); + close(fd); + if (0 < size) + return atoi(buf); + else + return -1; +} + +void ctui_set_view_mode(int addressbook_id) +{ + PH_TRACE; + int fd; + char buf[PH_TEXT_SHORT_LEN] = { 0 }; + + fd = open(VIEW_MODE_PATH, O_WRONLY | O_CREAT | O_TRUNC, 0644); + p_retm_if(fd < 0, "Open(%s) Failed", VIEW_MODE_PATH); + snprintf(buf, sizeof(buf), "%d", addressbook_id); + if (-1 == write(fd, buf, strlen(buf))) + ERR("write()... Failed(%s)", strerror(errno)); + close(fd); +} + +contacts_error_e phone_cts_get_default_number(int person_id, + contacts_record_h *record_clone) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + contacts_list_h list = NULL; + contacts_filter_h filter = NULL; + contacts_query_h query = NULL; + + p_retvm_if(NULL == record_clone, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(record_clone) is NULL"); + + err = (contacts_error_e) contacts_query_create(_contacts_person_number._uri, + &query); + p_retvm_if(CONTACTS_ERROR_NONE != err, err, + "contacts_query_create() Failed(%d)", err); + + err = (contacts_error_e) contacts_filter_create( + _contacts_person_number._uri, &filter); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_filter_create() Failed(%d)", err); + contacts_query_destroy(query); + return err; + } + + do + { + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_int(filter, + _contacts_person_number.person_id, CONTACTS_MATCH_EQUAL, + person_id))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_operator( + filter, CONTACTS_FILTER_OPERATOR_AND))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_bool(filter, + _contacts_person_number.is_primary_default, true))) + break; + if (CONTACTS_ERROR_NONE != (err = + (contacts_error_e) contacts_query_set_filter(query, filter))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_db_get_records_with_query( + query, 0, 0, &list))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_list_get_current_record_p( + list, &record))) + break; + if (CONTACTS_ERROR_NONE != (err = + (contacts_error_e) contacts_record_clone(record, record_clone))) + break; + + contacts_query_destroy(query); + contacts_filter_destroy(filter); + contacts_list_destroy(list, true); + + return CONTACTS_ERROR_NONE; + } + while (0); + + contacts_query_destroy(query); + contacts_filter_destroy(filter); + if (list) + contacts_list_destroy(list, true); + + return err; +} + +contacts_error_e phone_cts_get_default_email(int person_id, + contacts_record_h *record_clone) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + contacts_list_h list = NULL; + contacts_filter_h filter = NULL; + contacts_query_h query = NULL; + + p_retvm_if(NULL == record_clone, CONTACTS_ERROR_INVALID_PARAMETER, + "parameter(record_clone) is NULL"); + + err = (contacts_error_e) contacts_query_create(_contacts_person_email._uri, + &query); + p_retvm_if(CONTACTS_ERROR_NONE != err, err, + "contacts_query_create() Failed(%d)", err); + + err = (contacts_error_e) contacts_filter_create(_contacts_person_email._uri, + &filter); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_filter_create() Failed(%d)", err); + contacts_query_destroy(query); + return err; + } + + do + { + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_int(filter, + _contacts_person_email.person_id, CONTACTS_MATCH_EQUAL, + person_id))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_operator( + filter, CONTACTS_FILTER_OPERATOR_AND))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_filter_add_bool(filter, + _contacts_person_email.is_primary_default, true))) + break; + if (CONTACTS_ERROR_NONE != (err = + (contacts_error_e) contacts_query_set_filter(query, filter))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_db_get_records_with_query( + query, 0, 0, &list))) + break; + if (CONTACTS_ERROR_NONE + != (err = (contacts_error_e) contacts_list_get_current_record_p( + list, &record))) + break; + if (CONTACTS_ERROR_NONE != (err = + (contacts_error_e) contacts_record_clone(record, record_clone))) + break; + + contacts_query_destroy(query); + contacts_filter_destroy(filter); + contacts_list_destroy(list, true); + + return CONTACTS_ERROR_NONE; + } + while (0); + + contacts_query_destroy(query); + contacts_filter_destroy(filter); + + if (list) + contacts_list_destroy(list, true); + return err; +} + +bool ctui_list_make_vcard(int person_id, char *path, int path_length) +{ + PH_TRACE; + int fd; + char *display = NULL; + char *vcard = NULL; + contacts_record_h record = NULL; + contacts_error_e err = CONTACTS_ERROR_NONE; + + err = (contacts_error_e) contacts_db_get_record(_contacts_person._uri, + person_id, &record); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_db_get_record() Failed(%d)", err); + return false; + } + + err = (contacts_error_e) contacts_record_get_str_p(record, + _contacts_person.display_name, &display); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_get_str_p() Failed(%d)", err); + + if (display && *display) + snprintf(path, path_length, "%s/%s.vcf", UGDATAIDR, display); + else + snprintf(path, path_length, "%s/%s.vcf", UGDATAIDR, + T_(CT_GET_TEXT_ERR, CTTEXT_NONAME)); + + err = (contacts_error_e) contacts_vcard_make_from_person(record, &vcard); + if (CONTACTS_ERROR_NONE != err) + { + ERR("contacts_vcard_make_from_person() Failed(%d)", err); + err = (contacts_error_e) contacts_record_destroy(record, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_destroy() Failed(%d)", err); + return false; + } + + fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); + + if (-1 == write(fd, vcard, strlen(vcard))) + { + ERR("write()... Failed(%s)", strerror(errno)); + free(vcard); + return false; + } + free(vcard); + return true; +} + +int ctui_get_addressbook_id_by_index(Eina_List *list, unsigned int index) +{ + PH_TRACE; + p_retvm_if(NULL == list, -1, "list is NULL"); + void *addressbook_id; + + if (eina_list_count(list) <= index) + { + ERR("index is bigger than count"); + return -1; + } + + addressbook_id = eina_list_nth(list, index); + + return (int) addressbook_id; +} + +Eina_List* ctui_get_addressbook_id_list(const char *ori_string, const char *sep) +{ + PH_TRACE; + Eina_List *e_list = NULL; + char *p = NULL; + char *copy_string; + char *save_p; + + if (!ori_string) + { + PH_DBG("Input string is NULL"); + return NULL; + } + + copy_string = SAFE_STRDUP(ori_string); + + if (copy_string) + { + p = strtok_r(copy_string, sep, &save_p); + + while (p) + { + int id = atoi(p); + if (eina_list_data_find(e_list, (void*) id) == NULL) + e_list = eina_list_append(e_list, (void*) id); + + p = strtok_r(NULL, sep, &save_p); + } + + free(copy_string); + } + + return e_list; +} + +Eina_List* __make_tokenize_list(const char *ori_string, const char *sep) +{ + PH_TRACE; + Eina_List *e_list = NULL; + char *p = NULL; + char *copy_string; + char *save_p; + + if (!ori_string) + { + PH_DBG("Input string is NULL"); + return NULL; + } + + copy_string = SAFE_STRDUP(ori_string); + + if (copy_string) + { + p = strtok_r(copy_string, sep, &save_p); + + if (p) + PH_DBG("list item = %s", p); + + while (p) + { + char *c = SAFE_STRDUP(p); + + e_list = eina_list_append(e_list, c); + + p = strtok_r(NULL, sep, &save_p); + + if (p) + PH_DBG("list item = %s", p); + } + + free(copy_string); + } + + return e_list; +} + +contacts_record_h ctui_get_record_image(contacts_record_h record_contact) +{ + PH_TRACE; + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + p_retvm_if(NULL == record_contact, NULL, + "parameter(record_contact) is NULL"); + + err = (contacts_error_e) contacts_record_get_child_record_at_p( + record_contact, _contacts_contact.image, 0, &record); + if (NULL != record) + return record; + + err = (contacts_error_e) contacts_record_create(_contacts_image._uri, + &record); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, + "contacts_record_create() Failed(%d)", err); + + err = (contacts_error_e) contacts_record_add_child_record(record_contact, + _contacts_contact.image, record); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_record_add_child_record() Failed(%d)", err); + + return record; +} + +Evas_Object *phone_create_toolbar_btn(Evas_Object *parent, const char *text, + Evas_Smart_Cb func, void *data) +{ + PH_TRACE; + const Evas_Coord height = 100; + if (!parent || !data) + { + return NULL; + } + Evas_Object *btn = elm_button_add(parent); + if (!btn) + { + return NULL; + } + evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(btn, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_object_style_set(btn, "naviframe/toolbar/default"); + elm_object_text_set(btn, text); + evas_object_size_hint_min_set(btn, 0, height); + evas_object_size_hint_max_set(btn, 999999, height); + evas_object_smart_callback_add(btn, "clicked", func, data); + evas_object_show(btn); + return btn; +} + +int ctui_get_addressbook_id(char* addressbook_name) +{ + PH_TRACE; + PH_DBG("addressbook_name = %s", addressbook_name); + contacts_error_e err = CONTACTS_ERROR_NONE; + contacts_filter_h filter = NULL; + contacts_query_h query = NULL; + contacts_list_h list = NULL; + contacts_record_h record = NULL; + unsigned int count = 0; + int addressbook_id = -1; //0 is phone addressbook id + + err = (contacts_error_e) contacts_filter_create(_contacts_address_book._uri, + &filter); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contactcs_filter_create() Failed(%d)", err); + + err = (contacts_error_e) contacts_filter_add_str(filter, + _contacts_address_book.name, CONTACTS_MATCH_FULLSTRING, + addressbook_name); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_filter_add_str() Failed(%d)", err); + err = (contacts_error_e) contacts_query_create(_contacts_address_book._uri, + &query); + p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_create() Failed(%d)", + err); + err = (contacts_error_e) contacts_query_set_filter(query, filter); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_query_set_filter() Failed(%d)", err); + err = (contacts_error_e) contacts_db_get_records_with_query(query, 0, 0, + &list); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_db_get_records_with_query() Failed(%d)", err); + + if (list != NULL) + { + err = (contacts_error_e) contacts_list_get_count(list, &count); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_list_get_count() Failed(%d)", err); + PH_DBG("count = %d", count); + if (count > 0) + { + err = (contacts_error_e) contacts_list_get_current_record_p(list, + &record); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_list_get_current_record_p() Failed(%d)", err); + contacts_record_get_int(record, _contacts_address_book.id, + &addressbook_id); + err = (contacts_error_e) contacts_list_destroy(list, true); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_list_destroy() Failed(%d)", err); + } + } + err = (contacts_error_e) contacts_filter_destroy(filter); + p_warn_if(CONTACTS_ERROR_NONE != err, + "contacts_filter_destroy() Failed(%d)", err); + err = (contacts_error_e) contacts_query_destroy(query); + p_warn_if(CONTACTS_ERROR_NONE != err, "contacts_query_destroy() Failed(%d)", + err); + + PH_DBG("addressbook id = %d", addressbook_id); + return addressbook_id; + +} + +void ctui_create_contacts_error_popup(Evas_Object *parent, int err) +{ + PH_TRACE; + p_retm_if(CONTACTS_ERROR_NONE == err, + "ctui_create_contacts_error_popup no errer"); + p_retm_if(NULL == parent, + "ctui_create_contacts_error_popup parent is null"); + + ERR("ctui_create_contacts_error_popup() err(%d)", err); + switch (err) + { + case CONTACTS_ERROR_DB: + phone_show_popup(parent, T_(CT_GET_TEXT_ERR, CTTEXT_ERR_DB_LOCKED), + 1.5); + break; + case CONTACTS_ERROR_FILE_NO_SPACE: + phone_show_popup(parent, S_(CT_SYS_POP_NOT_ENOUGH_MEMORY), 1.5); + break; + default: + phone_show_popup(parent, S_(PH_SYS_POP_FAILED), 1.5); + break; + } + + return; +} + +bool hasBadge() +{ + PH_TRACE; + bool badgeExists(false); + badge_error_e badgeRes = badge_is_existing(DIALER_PKG, &badgeExists); + p_warn_if(BADGE_ERROR_NONE != badgeRes, "badge_is_existing is failed(%d)", badgeRes); + if (badgeRes != BADGE_ERROR_NONE) + { + badgeExists = false; + } + + return badgeExists; +} + +bool removeBadge() +{ + PH_TRACE; + bool shouldRemove(hasBadge()); + if (shouldRemove) + { + badge_remove(DIALER_PKG); + } + + return shouldRemove; +} + +void phone_set_searchbar_add_button_visible(ct_list_data &clist_d, bool visible) +{ + PH_TRACE; + Evas_Object * add_button = (Evas_Object *) evas_object_data_get(clist_d.searchbar, "add_button"); + if(add_button) + { + if(visible) + { + elm_object_part_content_set(clist_d.searchbar, "add_button_show_swall_search", clist_d.search_layout); + elm_object_part_content_set(clist_d.searchbar,"button_add",add_button); + } + else + { + elm_object_part_content_set(clist_d.searchbar, "add_button_hide_swall_search", clist_d.search_layout); + elm_object_part_content_unset(clist_d.searchbar, "button_add"); + evas_object_hide(add_button); + } + } +} + +bool phone_copy_to_dialing_screen(const std::string& number) +{ + PH_TRACE; + bool result(false); + service_h service = NULL; + std::string uri = "tel:" + number; + + if(service_create(&service) == SERVICE_ERROR_NONE) + { + if( service_set_package(service, DIALER_PKG) == SERVICE_ERROR_NONE + && service_set_operation(service, + "http://tizen.org/appcontrol/operation/dial") == SERVICE_ERROR_NONE + && service_set_uri(service, uri.c_str()) == SERVICE_ERROR_NONE) + { + if( service_send_launch_request(service, NULL, NULL) == SERVICE_ERROR_NONE) + { + result = (service_destroy(service) == SERVICE_ERROR_NONE); + } + } + } + return result; +} + +char* phone_get_datetime_str(UDateFormat* formatter, int year, int month, + int day) +{ + PH_TRACE; + time_t timer; + struct tm stime; + char *ret_str = NULL; + char formatted_str[PH_TEXT_SHORT_LEN]; + int32_t formattedCapacity; + UChar formatted[PH_TEXT_SHORT_LEN]; + UErrorCode status = U_ZERO_ERROR; + if(formatter) + { + memset(&stime, 0, sizeof(struct tm)); + stime.tm_year = year - 1900; + stime.tm_mon = month - 1; + stime.tm_mday = day; + timer = mktime(&stime); + + formattedCapacity = (int32_t)(sizeof(formatted) / sizeof((formatted)[0])); + udat_format(formatter, (UDate) timer * 1000, formatted, formattedCapacity, + NULL, &status); + p_retvm_if(U_FAILURE(status), NULL, "udat_format() Failed()"); + + u_austrcpy(formatted_str, formatted); + ret_str = strdup(formatted_str); + } + + return ret_str; +} + +// TODO: Fixme +int phone_get_address_type_index(int type) +{ + PH_TRACE; + switch (type) + { + case CONTACTS_ADDRESS_TYPE_CUSTOM: + return 1; + case CONTACTS_ADDRESS_TYPE_HOME: + return 2; + case CONTACTS_ADDRESS_TYPE_WORK: + return 3; + default: + return 0; + } +} + +// TODO: Fixme +int phone_get_website_type_index(int type) +{ + PH_TRACE; + switch (type) + { + case CONTACTS_URL_TYPE_CUSTOM: + return 1; + case CONTACTS_URL_TYPE_HOME: + return 2; + case CONTACTS_URL_TYPE_WORK: + return 3; + default: + return 0; + } +} + +int phone_get_number_type_index(int ct_num_type) +{ + PH_TRACE; + int ret_type; + + switch (ct_num_type) + { + case CTTEXT_TYPE_MOBILE: + ret_type = CONTACTS_NUMBER_TYPE_CELL; + break; + case CTTEXT_TYPE_HOME: + ret_type = CONTACTS_NUMBER_TYPE_VOICE | CONTACTS_NUMBER_TYPE_HOME; + break; + case CTTEXT_TYPE_HOME2: + ret_type = CONTACTS_NUMBER_TYPE_CELL | CONTACTS_NUMBER_TYPE_HOME; + break; + case CTTEXT_TYPE_WORK: + ret_type = CONTACTS_NUMBER_TYPE_VOICE | CONTACTS_NUMBER_TYPE_WORK; + break; + case CTTEXT_TYPE_WORK2: + ret_type = CONTACTS_NUMBER_TYPE_CELL | CONTACTS_NUMBER_TYPE_WORK; + break; + case CTTEXT_TYPE_FAX_HOME: + ret_type = CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_HOME; + break; + case CTTEXT_TYPE_FAX_WORK: + ret_type = CONTACTS_NUMBER_TYPE_FAX | CONTACTS_NUMBER_TYPE_WORK; + break; + case CTTEXT_TYPE_ASSISTANT: + ret_type = CONTACTS_NUMBER_TYPE_ASSISTANT; + break; + case CTTEXT_TYPE_PAGER: + ret_type = CONTACTS_NUMBER_TYPE_PAGER; + break; + case CTTEXT_TYPE_CAR: + ret_type = CONTACTS_NUMBER_TYPE_CAR; + break; + case CTTEXT_TYPE_CUSTOM: + ret_type = CONTACTS_NUMBER_TYPE_CUSTOM; + break; + case CTTEXT_TYPE_OTHER: + default: + ret_type = CONTACTS_NUMBER_TYPE_OTHER; + break; + } + + return ret_type; +} + +UDateFormat* phone_init_time_formatter(void) +{ + PH_TRACE; + UChar pattern[PH_TEXT_SHORT_LEN] = {0,}; + UChar customSkeleton[PH_TEXT_SHORT_LEN] = {0,}; + UDateFormat *formatter = NULL; + UErrorCode status = U_ZERO_ERROR; + + u_uastrncpy(customSkeleton, UDAT_YEAR_MONTH_DAY, + strlen(UDAT_YEAR_MONTH_DAY)); + + const char *locale = uloc_getDefault(); + p_retvm_if(NULL == locale, NULL, "uloc_getDefault() return NULL"); + + UDateTimePatternGenerator *generator = udatpg_open(locale, &status); + p_retvm_if(U_FAILURE(status), NULL, "udatpg_open() Failed()"); + + int32_t pattern_capacity = (int32_t)(sizeof(pattern) / sizeof((pattern)[0])); + udatpg_getBestPattern(generator, customSkeleton, 6, pattern, + pattern_capacity, &status); + + if (!U_FAILURE(status)) + formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, + pattern, -1, &status); + + udatpg_close(generator); + return formatter; +} + +void phone_destroy_confirm_popup_data(ct_confirm_popup_data* p_popup_data) +{ + PH_TRACE; + p_retm_if(NULL == p_popup_data, "popup data is null"); + p_popup_data->parent = NULL; + evas_object_del(p_popup_data->button1); + p_popup_data->button1 = NULL; + evas_object_del(p_popup_data->button2); + p_popup_data->button2 = NULL; + free(p_popup_data->popup_label); + p_popup_data->popup_label = NULL; + free(p_popup_data->button1_label); + p_popup_data->button1_label = NULL; + free(p_popup_data->button2_label); + p_popup_data->button2_label = NULL; + p_popup_data->button1_cb = NULL; + p_popup_data->button2_cb = NULL; + p_popup_data->button1_data = NULL; + p_popup_data->button2_data = NULL; + evas_object_del(p_popup_data->popup); + p_popup_data->popup = NULL; +} + +bool phone_fill_confirm_popup_data(ct_confirm_popup_data* p_popup_data) +{ + PH_TRACE; + p_retvm_if(NULL == p_popup_data, false, "pointer to popup data is null"); + p_retvm_if(NULL == p_popup_data->parent, false, "parent is null"); + + Evas_Object *p_popup = elm_popup_add(p_popup_data->parent); + p_retvm_if(NULL == p_popup, NULL, "p_popup is null"); + elm_object_part_text_set(p_popup,TITLE_TEXT, p_popup_data->popup_label); + evas_object_size_hint_weight_set(p_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + + Evas_Object *p_ok_button = elm_button_add(p_popup); + p_retvm_if(NULL == p_ok_button, NULL, "p_cancel_button is null"); + elm_object_text_set(p_ok_button, p_popup_data->button1_label); + elm_object_part_content_set(p_popup, BUTTON1, p_ok_button); + elm_object_style_set(p_ok_button, "popup_button/default"); + evas_object_smart_callback_add(p_ok_button, CLICKED, p_popup_data->button1_cb, p_popup_data->button1_data); + + Evas_Object *p_cancel_button = elm_button_add(p_popup); + p_retvm_if(NULL == p_cancel_button, NULL, "p_cancel_button is null"); + elm_object_text_set(p_cancel_button, p_popup_data->button2_label); + elm_object_part_content_set(p_popup, BUTTON2, p_cancel_button); + elm_object_style_set(p_cancel_button, "popup_button/default"); + evas_object_smart_callback_add(p_cancel_button, CLICKED, p_popup_data->button2_cb, p_popup_data->button2_data); + + bool result = (p_popup && p_ok_button && p_cancel_button); + if(result) + { + p_popup_data->popup = p_popup; + p_popup_data->button1 = p_ok_button; + p_popup_data->button2 = p_cancel_button; + } + return result; +} + +int phone_get_contact_id_by_person_id(int personId) +{ + PH_TRACE; + int retId(0); + contacts_list_h tempList= NULL; + if(get_records_list(_contacts_contact._uri, _contacts_contact.person_id, personId, &tempList)) + { + contacts_record_h tempRecord = NULL; + if(contacts_list_get_current_record_p(tempList, &tempRecord) + == CONTACTS_ERROR_NONE) + { + if(contacts_record_get_int(tempRecord, _contacts_contact.id, &retId) + != CONTACTS_ERROR_NONE) + { + ERR("error getting contact ID"); + } + } + } + contacts_list_destroy(tempList, true); + return retId; +} + +const char * phone_get_group_name(contacts_record_h group_record) +{ + char *system_id = NULL; + int err = contacts_record_get_str_p(group_record, _contacts_group.extra_data, &system_id); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "contacts_record_get_str_p() is Failed(%d)"); + + if (system_id) + { + const char *name = NULL; + if (strcmp(system_id, "friends") == 0) + name = T_(CT_GET_TEXT_BASIC, CTTEXT_FRIENDS); + else if (strcmp(system_id, "family") == 0) + name = T_(CT_GET_TEXT_BASIC, CTTEXT_FAMILY); + else if (strcmp(system_id, "coworkers") == 0) + name = T_(CT_GET_TEXT_BASIC, CTTEXT_CO_WORKERS); + else if (strcmp(system_id, "emergency") == 0) + name = T_(CT_GET_TEXT_BASIC, CTTEXT_EMERGENCY_CONTACTS); + else + name = T_(CT_GET_TEXT_ERR, CTTEXT_NONAME); + + return name; + } + else + { + char *name = NULL; + err = contacts_record_get_str_p(group_record, _contacts_group.name, &name); + p_retvm_if(CONTACTS_ERROR_NONE != err, NULL, "contacts_record_get_str_p() is Failed(%d)"); + return name; + } +} + +bool has_emergency_contacts() +{ + PH_TRACE; + int ret = CONTACTS_ERROR_NONE; + contacts_record_h record = NULL; + contacts_list_h group_list = NULL; + + phone_cts_get_list(_contacts_group._uri, _contacts_group.address_book_id, 0, &group_list); + CONTACTS_LIST_FOREACH(group_list, record) + { + char* group_name = NULL; + ret = contacts_record_get_str_p(record, _contacts_group.extra_data, &group_name); + if (group_name != NULL) + { + if (CONTACTS_ERROR_NONE == ret) + { + if (strcmp(group_name, EMERGENCY) == 0) + { + phone_cts_free_list(group_list); + return true; + } + } + } + } + phone_cts_free_list(group_list); + return false; +} + +void create_emergency_contacts_group() +{ + PH_TRACE; + contacts_record_h group_record = NULL; + int id_grp = 0; + + int ret = contacts_record_create(_contacts_group._uri, &group_record); + if (CONTACTS_ERROR_NONE == ret) + { + ret = contacts_record_set_str(group_record, _contacts_group.name, EMERGENCY); + ret = contacts_record_set_str(group_record, _contacts_group.extra_data, EMERGENCY); + if (CONTACTS_ERROR_NONE == ret) + { + ret = contacts_db_insert_record(group_record, &id_grp); + } + ret = contacts_record_destroy(group_record, true); + p_retm_if(CONTACTS_ERROR_NONE != ret, "contacts_record_destroy() Failed(%d)"); + } +} + +static void phone_popup_hide_cb(void *data, Evas_Object *obj, void *event_info) +{ + if(data) + { + evas_object_hide((Evas_Object *) data); + } +} + +Evas_Object * phone_popup_add_button(Evas_Object *popup, const char *text, Evas_Smart_Cb func, void *data) +{ + static const char *button_parts[] = + { + "button1", + "button2", + "button3", + NULL + }; + const char **part = button_parts; + Evas_Object *button = NULL; + + while(*part && elm_object_part_content_get(popup, *part)) + { + ++part; + } + + p_retvm_if(NULL == part, NULL, "No empty button parts left"); + + button = elm_button_add(popup); + p_retvm_if(NULL == button, NULL, "Failed to create button"); + elm_object_style_set(button, "popup_button/default"); + elm_object_text_set(button, text); + elm_object_part_content_set(popup, *part, button); + evas_object_smart_callback_add(button, "clicked", phone_popup_hide_cb, popup); + evas_object_smart_callback_add(button, "clicked", func, data); + + return button; +} + +char* phone_get_contact_name(int id) +{ + p_retvm_if(0 >= id, NULL, "incorrect id"); + char* contact_name = NULL; + contacts_record_h contact = NULL; + + if (contacts_db_get_record(_contacts_contact._uri, id, &contact) == CONTACTS_ERROR_NONE) + { + if(contacts_record_get_str(contact, _contacts_contact.display_name, &contact_name) != CONTACTS_ERROR_NONE) + { + ERR("getting contact name failed"); + free(contact_name); + contact_name = NULL; + } + contacts_record_destroy(contact, true); + } + PH_DBG("contact_name: %s", contact_name); + return contact_name; +} + +Elm_Genlist_Item_Class* phone_create_item_class(const char* style, const char* decorate_style, const char* decorate_all_style, + Elm_Gen_Item_Text_Get_Cb get_text, Elm_Gen_Item_Content_Get_Cb get_content, + Elm_Gen_Item_State_Get_Cb get_state, Elm_Gen_Item_Del_Cb del_func) +{ + PH_TRACE; + Elm_Genlist_Item_Class *item_class = elm_genlist_item_class_new(); + p_retvm_if(NULL == item_class, NULL, "item_class is null"); + + item_class->item_style = style; + item_class->decorate_item_style = decorate_style; + item_class->decorate_all_item_style = decorate_all_style; + item_class->func.text_get = get_text; + item_class->func.content_get = get_content; + item_class->func.state_get = get_state; + item_class->func.del = del_func; + return item_class; +} + +static void phone_hide_block_contact_popup_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)data; + p_retm_if(NULL == p_block_contact_data->p_popup_data, "popup data is null"); + p_retm_if(NULL == p_block_contact_data->p_popup_data->popup, "popup is null"); + evas_object_hide(p_block_contact_data->p_popup_data->popup); +} + + +void phone_destroy_block_contact_popup_cb(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)data; + + if(p_block_contact_data->p_popup_data) + { + phone_destroy_confirm_popup_data(p_block_contact_data->p_popup_data); + p_block_contact_data->p_popup_data = NULL; + } + if(p_block_contact_data->msg_handle) + { + msg_close_msg_handle(&p_block_contact_data->msg_handle); + p_block_contact_data->msg_handle = NULL; + } + p_block_contact_data->contact_id = 0; + free(p_block_contact_data); +} + +bool phone_check_number_in_spam_for_messages(msg_handle_t msg_handle, const char *number) +{ + PH_TRACE; + p_retvm_if(NULL == msg_handle, false, "msgHandle is NULL"); + p_retvm_if(NULL == number, false, "address is NULL"); + bool result(false); + msg_struct_list_s filter_list = {0,}; + + if(msg_get_filter_list(msg_handle, &filter_list) == MSG_SUCCESS) + { + if (filter_list.nCount == 0) + { + result = false; + } + else + { + int i = 0; + int filter_type = -1; + char filter_address[DEF_BUF_LEN] = {0,}; + for (i = 0; i < filter_list.nCount; ++i) + { + msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_TYPE_INT, &filter_type); + if (filter_type == MSG_FILTER_BY_ADDRESS_SAME) + { + msg_get_str_value(filter_list.msg_struct_info[i], MSG_FILTER_VALUE_STR, filter_address, sizeof(filter_address)); + if (strncmp(filter_address, number, sizeof(filter_address)) == 0) + { + result = true; + break; + } + } + } + } + } + + msg_release_list_struct(&filter_list); + return result; +} + +bool phone_add_number_to_spam_for_messages(msg_handle_t msg_handle, const char* number) +{ + PH_TRACE; + p_retvm_if(NULL == msg_handle, false, "msgHandle is null"); + p_retvm_if(NULL == number, false, "number is null"); + bool result(false); + msg_error_t err = MSG_SUCCESS; + msg_struct_t filter = msg_create_struct(MSG_STRUCT_FILTER); + + msg_set_int_value(filter, MSG_FILTER_TYPE_INT, MSG_FILTER_BY_ADDRESS_SAME); + msg_set_str_value(filter, MSG_FILTER_VALUE_STR, (char *)number, DEF_MAX_FILTER_LEN); + msg_set_filter_operation(msg_handle, true); + + err = msg_add_filter(msg_handle, filter); + if (err != MSG_SUCCESS) + { + ERR("failed to add filter"); + msg_release_struct(&filter); + } + else + { + result = true; + } + + if (filter) + { + msg_release_struct(&filter); + } + return result; +} + +bool phone_delete_number_from_spam_for_messages(msg_handle_t msg_handle, const char* number) +{ + PH_TRACE; + bool result(false); + p_retvm_if(NULL == msg_handle, false, "msgHandle is NULL"); + p_retvm_if(NULL == number, false, "number is NULL"); + + msg_struct_list_s filter_list = {0,}; + + if(msg_get_filter_list(msg_handle, &filter_list) == MSG_SUCCESS) + { + + if (filter_list.nCount > 0) + { + int i = 0; + int filter_type = -1; + int filter_id = -1; + char filter_address[DEF_BUF_LEN] = {0,}; + + for (i = 0; i < filter_list.nCount; ++i) + { + msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_TYPE_INT, &filter_type); + if (filter_type == MSG_FILTER_BY_ADDRESS_SAME) + { + msg_get_str_value(filter_list.msg_struct_info[i], MSG_FILTER_VALUE_STR, filter_address, sizeof(filter_address)); + if (strncmp(filter_address, number, sizeof(filter_address)) == 0) + { + msg_get_int_value(filter_list.msg_struct_info[i], MSG_FILTER_ID_INT, &filter_id); + break; + } + } + } + if (filter_id != -1) + { + msg_delete_filter(msg_handle, filter_id); + result = true; + } + } + } + msg_release_list_struct(&filter_list); + return result; +} + +bool phone_handle_contact_for_spam_messages(ct_contact_block_data* p_block_contact_data, number_handler_for_spam_messages handler_function) +{ + PH_TRACE; + p_retvm_if(NULL == handler_function, false, "func handler is null"); + bool result(false); + contacts_list_h number_list = NULL; + if(get_records_list(_contacts_number._uri, _contacts_number.contact_id, + p_block_contact_data->contact_id, &number_list)) + { + contacts_record_h record = NULL; + CONTACTS_LIST_FOREACH(number_list, record) + { + char* number = NULL; + if(contacts_record_get_str_p(record, _contacts_number.number, &number) == CONTACTS_ERROR_NONE) + { + if(handler_function(p_block_contact_data->msg_handle, number)) + { + result = true; + } + else + { + ERR("number is not blocked/unblocked"); + break; + } + } + } + } + contacts_list_destroy(number_list, true); + return result; +} + +static void phone_handle_blocking_contact_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)data; + + if(p_block_contact_data->block_calls != phone_is_blocked_contact_for_calls(p_block_contact_data->contact_id)) + { + if(!phone_toggle_blocked_contact_for_calls(p_block_contact_data->contact_id)) + { + ERR("Contact is not blocked/unblocked"); + } + } + + if(p_block_contact_data->block_messages) + { + phone_handle_contact_for_spam_messages(p_block_contact_data, phone_add_number_to_spam_for_messages); + } + else + { + phone_handle_contact_for_spam_messages(p_block_contact_data, phone_delete_number_from_spam_for_messages); + } + evas_object_hide(p_block_contact_data->p_popup_data->popup); +} + +static ct_confirm_popup_data* phone_create_block_confirm_popup(Evas_Object* parent, int contact_id, void* data) +{ + PH_TRACE; + ct_confirm_popup_data* inner_popup_as_data = NULL; + inner_popup_as_data = (ct_confirm_popup_data*)calloc(1, sizeof(ct_confirm_popup_data)); + inner_popup_as_data->parent = parent; + inner_popup_as_data->popup = NULL; + inner_popup_as_data->button1 = NULL; + inner_popup_as_data->button2 = NULL; + inner_popup_as_data->popup_label = phone_get_contact_name(contact_id); + inner_popup_as_data->button1_label = strdup(S_(PH_SYS_SK_OK)); + inner_popup_as_data->button2_label = strdup(S_(PH_SYS_SK_CANCEL)); + inner_popup_as_data->button1_cb = phone_handle_blocking_contact_cb; + inner_popup_as_data->button2_cb = phone_hide_block_contact_popup_cb; + inner_popup_as_data->button1_data = data; + inner_popup_as_data->button2_data = data; + return inner_popup_as_data; +} + +static char* phone_block_popup_genlist_item_text_get(void *data, Evas_Object *obj, const char *part) +{ + PH_TRACE; + p_retvm_if(NULL == data, NULL, "data is null"); + ct_contact_block_item_data* p_block_item_data = (ct_contact_block_item_data*)data; + return strdup(p_block_item_data->item_caption); +} + +bool phone_check_contact_in_spam_for_messages(msg_handle_t msg_handle, int contact_id) +{ + PH_TRACE; + bool result(false); + contacts_list_h number_list = NULL; + if(get_records_list(_contacts_number._uri, _contacts_number.contact_id, + contact_id, &number_list)) + { + contacts_record_h record = NULL; + CONTACTS_LIST_FOREACH(number_list, record) + { + char* number = NULL; + if(contacts_record_get_str_p(record, _contacts_number.number, &number) == CONTACTS_ERROR_NONE) + { + if(phone_check_number_in_spam_for_messages(msg_handle, number)) + { + result = true; + break; + } + } + } + } + contacts_list_destroy(number_list, true); + return result; +} + +static bool phone_contact_block_is_any_changes(ct_contact_block_data* p_block_contact_data) +{ + PH_TRACE; + p_retvm_if(NULL == p_block_contact_data, false, "data is null"); + return (p_block_contact_data->is_blocked_calls != p_block_contact_data->block_calls) + || (p_block_contact_data->is_blocked_messages != p_block_contact_data->block_messages); +} + +static void phone_block_popup_check(Elm_Object_Item* item, ct_contact_block_data* p_block_contact_data, bool* p_bool_value) +{ + PH_TRACE; + p_retm_if(NULL == item, "item is null"); + *p_bool_value = !(*p_bool_value); + elm_object_disabled_set(p_block_contact_data->p_popup_data->button1, + !phone_contact_block_is_any_changes(p_block_contact_data)); + elm_genlist_item_selected_set(item, EINA_FALSE); + Evas_Object* check = elm_object_item_part_content_get(item, "elm.icon"); + if(check) + { + elm_check_state_set(check, *p_bool_value); + } +} + +static void phone_block_check_calls_changed_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)data; + phone_block_popup_check((Elm_Object_Item*)event_info, p_block_contact_data, &p_block_contact_data->block_calls); +} + +static void phone_block_check_messages_changed_cb(void *data, Evas_Object *obj, void *event_info) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)data; + phone_block_popup_check((Elm_Object_Item*)event_info, p_block_contact_data, &p_block_contact_data->block_messages); +} + +static Evas_Object* phone_block_popup_genlist_item_content_get(void *data, Evas_Object *obj, const char *part) +{ + PH_TRACE; + p_retvm_if(NULL == data, NULL, "data is null"); + ct_contact_block_item_data* p_block_additional_data = (ct_contact_block_item_data*)data; + DBG("part: %s", part); + Evas_Object* check = elm_check_add(obj); + if(check) + { + evas_object_propagate_events_set(check, EINA_TRUE); + elm_check_state_set(check, *p_block_additional_data->is_checked); + } + return check; +} + +void phone_block_popup_item_deleter(void *data, Evas_Object *obj) +{ + PH_TRACE; + p_retm_if(NULL == data, "data is null"); + ct_contact_block_item_data* p_block_item_data = (ct_contact_block_item_data*)data; + free(p_block_item_data); +} + +Evas_Object* phone_create_block_contact_popup(Evas_Object* parent, int contact_id) +{ + PH_TRACE; + p_retvm_if(NULL == parent, NULL, "parent is null"); + p_retvm_if(contact_id < 1, NULL, "bad contact id"); + Evas_Object* result = NULL; + ct_contact_block_data* p_block_contact_data = (ct_contact_block_data*)calloc(1, sizeof(ct_contact_block_data)); + p_block_contact_data->contact_id = contact_id; + p_block_contact_data->p_popup_data = phone_create_block_confirm_popup(parent, contact_id, p_block_contact_data); + if(p_block_contact_data->p_popup_data) + { + if(msg_open_msg_handle(&p_block_contact_data->msg_handle) == MSG_SUCCESS) + { + if(phone_fill_confirm_popup_data(p_block_contact_data->p_popup_data)) + { + elm_object_style_set(p_block_contact_data->p_popup_data->popup, "content_no_vhpad"); + elm_object_disabled_set(p_block_contact_data->p_popup_data->button1, EINA_TRUE); + Elm_Genlist_Item_Class* genlist_item_class = phone_create_item_class("1text.1icon.3/popup", + NULL, NULL, phone_block_popup_genlist_item_text_get, phone_block_popup_genlist_item_content_get, NULL, phone_block_popup_item_deleter); + p_block_contact_data->genlist = elm_genlist_add(p_block_contact_data->p_popup_data->popup); + if(p_block_contact_data->genlist) + { + elm_object_content_set(p_block_contact_data->p_popup_data->popup, p_block_contact_data->genlist); + evas_object_size_hint_weight_set(p_block_contact_data->genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(p_block_contact_data->genlist, EVAS_HINT_FILL, EVAS_HINT_FILL); + + ct_contact_block_item_data* p_call_block_data = + (ct_contact_block_item_data*)malloc(sizeof(ct_contact_block_item_data)); + p_call_block_data->item_caption = T_(PH_GET_TEXT_BASIC, PHTEXT_CALLS); + p_call_block_data->is_checked = &p_block_contact_data->block_calls; + elm_genlist_item_append(p_block_contact_data->genlist, genlist_item_class, + p_call_block_data, NULL, ELM_GENLIST_ITEM_NONE, + phone_block_check_calls_changed_cb, p_block_contact_data); + + ct_contact_block_item_data* p_message_block_data = + (ct_contact_block_item_data*)malloc(sizeof(ct_contact_block_item_data)); + p_message_block_data->item_caption = T_(PH_GET_TEXT_BASIC, PHTEXT_MESSAGES); + p_message_block_data->is_checked = &p_block_contact_data->block_messages; + elm_genlist_item_append(p_block_contact_data->genlist, genlist_item_class, + p_message_block_data, NULL, ELM_GENLIST_ITEM_NONE, + phone_block_check_messages_changed_cb, p_block_contact_data); + + evas_object_show(p_block_contact_data->p_popup_data->popup); + evas_object_show(p_block_contact_data->genlist); + + p_block_contact_data->is_blocked_calls = + phone_is_blocked_contact_for_calls(p_block_contact_data->contact_id); + p_block_contact_data->is_blocked_messages = + phone_check_contact_in_spam_for_messages(p_block_contact_data->msg_handle, + p_block_contact_data->contact_id); + p_block_contact_data->block_calls = p_block_contact_data->is_blocked_calls; + p_block_contact_data->block_messages = p_block_contact_data->is_blocked_messages; + + evas_object_event_callback_add(p_block_contact_data->p_popup_data->popup, EVAS_CALLBACK_DEL, + phone_destroy_block_contact_popup_cb, p_block_contact_data); + + result = p_block_contact_data->p_popup_data->popup; + } + elm_genlist_item_class_free(genlist_item_class); + } + } + } + return result; +} |