path: root/lib/dialer/ph-dialer-view.c

/*
 * Copyright 2012  Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.tizenopensource.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 <string.h>
#include <malloc.h>
#include <Ecore_X.h>
#include <vconf.h>
#include <vconf-keys.h>

#include <TapiEvent.h>
#include <ui-gadget-module.h>

#include "phone.h"
#include "phone-dialer.h"

#include "ph-dialer-view.h"
#include "ph-dialer-utils.h"

#define PH_DIALER_ENTRY_DEFAULT_STYLE "<align=center font=SLP:style=Roman font_size=%d color=#ffffff>%s</>"
#define PH_DIALER_ENTRY_EMPTY_STYLE "<align=center font_size=%d>&#8203;</>"

static void dialer_entry_cursor_changed(void *data, Evas_Object *entry, void *event_info)
{
	ph_dialer_data *dial_d = data;
	dial_d->cursor_changed = true;
}

static void dialer_entry_mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
	ph_dialer_data *dial_d = data;
	if (dial_d->cursor_changed) {
		int pos = 0;
		dial_d->cursor_changed = false;
		pos = elm_entry_cursor_pos_get(dial_d->entry);
		dial_d->number_cursor = ph_dialer_util_get_node_by_index(data, pos);
	}
	dial_d->has_focus = true;
}

static void dialer_softkey_longpress(char *source, ph_dialer_data *dial_d)
{
	int pos = 0;
	char dest[PH_TEXT_MAX_LEN] = {0};

	if (strcmp(source, "star") == 0 || strcmp(source, "*") == 0) {
		if (ph_dialer_util_get_number_at_cursor(dial_d) == '*') {
			pos = ph_dialer_util_remove_node_at_cursor(dial_d);
			edje_object_signal_emit(_EDJ(dial_d->layout), "pad_clicked", "P");
			ph_dialer_util_get_numstr_from_node(dial_d, dest);
			ph_dialer_entry_set_number(dial_d, dest, 0, TRUE);
		}
	}
	else if (strcmp(source, "input_back") == 0)
		ph_dialer_util_entry_clear(dial_d);
}

static Eina_Bool dialer_keypad_longpress(void *data)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;
	int text_len = 0;
	int pos = 0;
	char dest[PH_TEXT_MAX_LEN] = {0};
	char *source;

	p_retv_if(NULL == dial_d, -1);

	source = dial_d->longpress_source;
	text_len = ph_dialer_util_get_pure_numstr_with_plus(dial_d, dest);

	switch (source[0]) {
	case '0' ... '9':
		PH_DBG("number(len=%d):[%s]", text_len, dest);
		if (source[0] == '0') {
			pos = ph_dialer_util_remove_node_at_cursor(dial_d);
			edje_object_signal_emit(_EDJ(dial_d->layout), "pad_clicked", "+");
			break;
		}
		break;
	default:
		dialer_softkey_longpress(source, dial_d);
		break;
	}
	if (dial_d->longpress_source) {
		free(dial_d->longpress_source);
		dial_d->longpress_source = NULL;
	}
	dial_d->longpress_timer = NULL;
	return ECORE_CALLBACK_CANCEL;
}

static void dialer_keypad_down(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	PH_FN_CALL;
	char dest[PH_TEXT_MAX_LEN] = {0};
	int snd_id = 0;
	ph_dialer_data *dial_d = data;

	p_retm_if(dial_d == NULL, "Invalid argument: ph_dialer_data *is NULL");
	p_retm_if(source == NULL, "source is NULL");

	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer = NULL;
	}

	if (dial_d->dash_timer) {
		ecore_timer_del(dial_d->dash_timer);
		dial_d->dash_timer = NULL;
	}

	switch (source[0]) {
	case '0' ... '9':
		snd_id = source[0] - '0';
		break;
	default:
		if (0 == strcmp(source, "star")) {
			source = "*";
			snd_id = 11;
		}
		else if (0 == strcmp(source, "sharp")) {
			source = "#";
			snd_id = 10;
		}
		break;
	}

	ph_dialer_util_strip_from_number_node(dial_d);
	ph_dialer_util_insert_number_at_cursor(dial_d, source[0]);
	ph_dialer_util_add_dashes(dial_d, DASH_REAL);
	ph_dialer_util_get_numstr_from_node(dial_d, dest);
	ph_dialer_entry_set_number(dial_d, dest, 0, TRUE);

	/* create new longpress timer */
	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer = NULL;
	}
	FREEandSTRDUP(dial_d->longpress_source, source);
	dial_d->longpress_timer = ecore_timer_add(elm_config_longpress_timeout_get(), dialer_keypad_longpress, dial_d);
}

static Eina_Bool dialer_dash_add_timer(void *data)
{
	char dest[PH_TEXT_MAX_LEN] = {0};
	ph_dialer_data *dial_d = data;

	ph_dialer_util_strip_from_number_node(dial_d);
	ph_dialer_util_add_dashes(dial_d, DASH_PREVIEW);
	ph_dialer_util_get_numstr_from_node(dial_d, dest);
	ph_dialer_entry_set_number(dial_d, dest, 0, TRUE);

	dial_d->dash_timer = NULL;
	return ECORE_CALLBACK_CANCEL;
}

static void dialer_keypad_up(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	ph_dialer_data *dial_d = data;
	p_retm_if(data == NULL, "Invalid argument: ph_dialer_data *is NULL");
	PH_DBG("(source=%s)", source);

	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer = NULL;
	}

	if (dial_d->dash_timer) {
		ecore_timer_del(dial_d->dash_timer);
		dial_d->dash_timer = NULL;
	}
	dial_d->dash_timer = ecore_timer_add(0.7, dialer_dash_add_timer, dial_d);
}

static void dialer_keypad_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;
	char dest[PH_TEXT_MAX_LEN] = {0};

	p_retm_if(NULL == source, "source is null");
	p_retm_if(NULL == data, "Invalid argument: ph_dialer_data is NULL");

	if (strcmp(source, "+") !=0 && strcmp(source, "P") !=0)
		return;

	if (dial_d->dash_timer) {
		ecore_timer_del(dial_d->dash_timer);
		dial_d->dash_timer = NULL;
	}

	ph_dialer_util_strip_from_number_node(dial_d);
	ph_dialer_util_insert_number_at_cursor(dial_d, source[0]);
	ph_dialer_util_add_dashes(dial_d, DASH_REAL);
	ph_dialer_util_get_numstr_from_node(dial_d, dest);
	ph_dialer_entry_set_number(dial_d, dest, 0, FALSE);
}

static void dialer_softkey_down(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	PH_FN_CALL;
	char dest[PH_TEXT_MAX_LEN] = {0};
	ph_dialer_data *dial_d = data;
	p_retm_if(data == NULL, "Invalid argument: ph_dialer_data *is NULL");

	if (0 != strcmp(source, "input_back"))
		return;

	if (dial_d->dash_timer) {
		ecore_timer_del(dial_d->dash_timer);
		dial_d->dash_timer = NULL;
	}

	ph_dialer_util_strip_from_number_node(dial_d);
	ph_dialer_util_remove_node_at_cursor(dial_d);
	ph_dialer_util_add_dashes(dial_d, DASH_REAL);
	ph_dialer_util_get_numstr_from_node(dial_d, dest);
	ph_dialer_entry_set_number(dial_d, dest, 0, FALSE);

	if (!*dest && dial_d->has_focus) {
		elm_object_focus_set(dial_d->entry, EINA_FALSE);
		dial_d->has_focus = false;
	}

	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer = NULL;
	}
	FREEandSTRDUP(dial_d->longpress_source, source);
	dial_d->longpress_timer =ecore_timer_add(elm_config_longpress_timeout_get(), dialer_keypad_longpress, dial_d);

}

static void dialer_softkey_up(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;
	p_retm_if(NULL == data, "Invalid argument: ph_dialer_data *is NULL");

	if (0 != strcmp(source, "input_back"))
		return;

	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer = NULL;
	}

	if (dial_d->dash_timer) {
		ecore_timer_del(dial_d->dash_timer);
		dial_d->dash_timer = NULL;
	}
	dial_d->dash_timer = ecore_timer_add(0.7, dialer_dash_add_timer, dial_d);
	PH_FN_END;
}

static void dialer_softkey_call_clicked(void *data, int type)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;
	char buf[PH_TEXT_MAX_LEN] = {0};
	int len;

	p_retm_if(data == NULL, "Invalid argument: ph_dialer_data *is NULL");

	len = ph_dialer_util_get_numstr_from_node(dial_d, buf);
	if (len == 0) {
		PH_DBG("text is NULL so input recent number ");
		char *get_str;
		if (0 == type)
			get_str = contacts_svc_phonelog_get_last_number(CTS_PLOG_LAST_CALL_ONLY);

		if (get_str) {
			ph_dialer_util_append_node_from_numstr(dial_d, get_str);
			ph_dialer_util_add_dashes(dial_d, DASH_REAL);
			ph_dialer_util_get_numstr_from_node(dial_d, buf);
			ph_dialer_entry_set_number(dial_d, buf, CURSOR_END, TRUE);
			free(get_str);
		}
		return;
	}
	if (0 == type)
		ph_dialer_util_launch_call(dial_d);
}

static void dialer_softkey_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;
	char buf[PH_TEXT_MAX_LEN] = {0};
	p_retm_if(data == NULL, "Invalid argument: ph_dialer_data *is NULL");

	PH_DBG("source:[%s]", source);

	if (dial_d->longpress_timer) {
		ecore_timer_del(dial_d->longpress_timer);
		dial_d->longpress_timer=NULL;
	}

	if (strstr(source, "call") != NULL)        /* normal/call, dc/call */
		dialer_softkey_call_clicked(dial_d, 0);

	ph_dialer_util_get_numstr_from_node(dial_d, buf);

	if (strcmp(source, "input_back") != 0)
		ph_dialer_entry_set_number(dial_d, buf, CURSOR_END, TRUE);
	else
		ph_dialer_entry_set_number(dial_d, buf, 0, TRUE);
}

static void dialer_entry_set_number_noresize(ph_dialer_data *dial_d, char *text)
{
	PH_FN_CALL;
	int size = MAX_DIAL_NUMBER_FONT_SIZE;
	char buf[PH_TEXT_MAX_LEN] = {0};
	int pos;

	if (text && *text)
		snprintf(buf, sizeof(buf), PH_DIALER_ENTRY_DEFAULT_STYLE, size, text);
	else
		snprintf(buf, sizeof(buf), PH_DIALER_ENTRY_EMPTY_STYLE, size);
	elm_entry_entry_set(dial_d->entry, buf);

	if (text && *text)
		edje_object_signal_emit(_EDJ(dial_d->layout), "input_back/default", "input_back");
	else
		edje_object_signal_emit(_EDJ(dial_d->layout), "input_back/dim", "input_back");

	pos = ph_dialer_util_get_cursor_pos(dial_d);
	elm_entry_cursor_pos_set(dial_d->entry, pos);
}

void ph_dialer_entry_set_number(ph_dialer_data *dial_d, char *orig, int cursor, int is_need_emit)
{
	char text[PH_TEXT_MAX_LEN] = {0};

	if (is_need_emit == TRUE) {
		if (orig && *orig)
			edje_object_signal_emit(_EDJ(dial_d->layout), "input_back/default", "input_back");
		else
			edje_object_signal_emit(_EDJ(dial_d->layout), "input_back/dim", "input_back");
	}

	if (orig && *orig)
		snprintf(text, sizeof(text), PH_DIALER_ENTRY_DEFAULT_STYLE, dial_d->entry_font_size, orig);
	else
		snprintf(text, sizeof(text), PH_DIALER_ENTRY_EMPTY_STYLE, dial_d->entry_font_size);
	elm_entry_entry_set(dial_d->entry, text);

	if (cursor == CURSOR_END)
		cursor = STRLEN(orig);
	else if (cursor == CURSOR_BEGIN)
		cursor = 0;
	else if (cursor == 0)
		cursor = ph_dialer_util_get_cursor_pos(dial_d);

	dial_d->number_cursor = ph_dialer_util_get_node_by_index(dial_d, cursor);
	elm_entry_cursor_pos_set(dial_d->entry, cursor);
}

static void dialer_view_delete_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;

	ph_dialer_util_del_all_number(dial_d);

	if (dial_d->popup)
		evas_object_del(dial_d->popup);

	if (dial_d->job)
		ecore_job_del(dial_d->job);

	if (dial_d->dash_timer)
		ecore_timer_del(dial_d->dash_timer);

	if (dial_d->longpress_timer)
		ecore_timer_del(dial_d->longpress_timer);

	free(dial_d->longpress_source);
	free(dial_d->init_text);
	free(dial_d);
}

static void dialer_entry_font_check(Evas_Object *entry, ph_dialer_data *dial_d, char *text, int pos)
{
	static int status = 0;
	Ecore_X_Window win;
	int size;
	int win_width;
	int entry_width;
	char buf[PH_TEXT_MAX_LEN] = {0};

	win = ecore_x_window_root_get(ecore_x_window_focus_get());
	ecore_x_window_size_get(win, &win_width, NULL);
	evas_object_size_hint_min_get(entry, &entry_width, NULL);

	size = dial_d->entry_font_size;

	if (win_width < entry_width) {
		if (MIN_DIAL_NUMBER_FONT_SIZE < size) {
			size--;
			snprintf(buf, sizeof(buf), PH_DIALER_ENTRY_DEFAULT_STYLE, size, text);
			status = -1;
			dial_d->entry_font_size = size;
			elm_entry_entry_set(dial_d->entry, buf);
			elm_entry_cursor_pos_set(dial_d->entry, pos);
		}
	}
	else if (entry_width < win_width) {
		if (status == -1) {
			status = 0;
			return;
		}
		if (size < MAX_DIAL_NUMBER_FONT_SIZE) {
			size++;
			snprintf(buf, sizeof(buf), PH_DIALER_ENTRY_DEFAULT_STYLE, size, text);
			status = 1;
			dial_d->entry_font_size = size;
			elm_entry_entry_set(dial_d->entry, buf);
			elm_entry_cursor_pos_set(dial_d->entry, pos);
		}
	}
	else
		status = 0;
}

static int dialer_include_zero_space(char *text)
{
	int len;
	int i;

	p_retv_if(NULL == text, -1);

	len = strlen(text);
	for (i = 0;i<len-2;i++) {
		if (text[i] == (char)0xe2 && text[i+1] == (char)0x80 && text[i+2] == (char)0x8b)
			return i;
	}
	return -1;
}

static int dialer_trim_dash_from_numstr(char *src, char *dest_buf, int buf_size, int cursor)
{
	int number_index= 0;
	int scan_index = 0;
	int zero_pos;

	p_retvm_if(NULL == src || '\0' == *src, -1, "src is NULL");
	p_retvm_if(NULL == dest_buf, -1, "dest_buf is NULL");

	zero_pos = dialer_include_zero_space(src);

	while (src[scan_index] && number_index < buf_size) {
		if (scan_index == zero_pos) {
			scan_index += 3;
			if (number_index < cursor)
				cursor--;
			continue;
		}
		if (!ph_dialer_util_is_dash(src[scan_index]))
			dest_buf[number_index++] = src[scan_index];
		else if (number_index < cursor)
			cursor--;
		scan_index++;
	}
	dest_buf[number_index] = '\0';
	return cursor;
}

static void dialer_entry_text_changed(void *data, Evas_Object *obj, void *event_info)
{
	ph_dialer_data *dial_d = data;
	int pos, cursor;
	char node_text[PH_TEXT_MAX_LEN] = {0};
	char entry_text[PH_TEXT_MAX_LEN] = {0};
	char *org;
	char *text;
	int differ = 0;

	org = SAFE_STRDUP(elm_entry_entry_get(obj));
	p_retm_if(NULL == org , "entry text is null");
	text = elm_entry_markup_to_utf8(org);

	// set text when cut/copy/paste
	ph_dialer_util_get_pure_numstr_with_plus(dial_d, node_text);
	pos = elm_entry_cursor_pos_get(dial_d->entry);
	cursor = dialer_trim_dash_from_numstr(text, entry_text, sizeof(entry_text), pos);
	differ = strcmp(node_text, entry_text);

	if (0 <= dialer_include_zero_space(text) && strlen(text) == 3 && 0 == differ) {
		free(text);
		free(org);
		return;
	}
	else if (*text == '\0') {
		snprintf(node_text, sizeof(node_text), PH_DIALER_ENTRY_EMPTY_STYLE, dial_d->entry_font_size);
		elm_entry_entry_set(dial_d->entry, node_text);
		free(text);
		free(org);
		return;
	}

	if (0 != differ) {
		ph_dialer_util_append_node_from_numstr(dial_d, entry_text);
		dial_d->number_cursor = ph_dialer_util_get_node_by_index(dial_d, cursor);
		ph_dialer_util_add_dashes(dial_d, DASH_REAL);
		ph_dialer_util_get_numstr_from_node(dial_d, node_text);
		ph_dialer_entry_set_number(dial_d, node_text, 0, TRUE);
		free(text);
		free(org);
		return;
	}

	if (NULL == strstr(org,"font_size")) {
		if (MAX_DIAL_NUMBER_FONT_SIZE == dial_d->entry_font_size)	dial_d->entry_font_size--;
		else if (MIN_DIAL_NUMBER_FONT_SIZE == dial_d->entry_font_size)	dial_d->entry_font_size++;
	}
	dialer_entry_font_check(obj, dial_d, text, pos);
	free(text);
	free(org);
}

static void dialer_create_entry(ph_dialer_data *dial_d)
{
	Evas_Object *scroller;
	Evas_Object *entry;

	scroller = elm_scroller_add(dial_d->layout);
	elm_scroller_bounce_set(scroller, EINA_FALSE, EINA_FALSE);
	elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
	elm_scroller_content_min_limit(scroller, EINA_FALSE, EINA_TRUE);
	elm_object_part_content_set(dial_d->layout, "textblock/textarea", scroller);

	entry = elm_entry_add(dial_d->layout);
	elm_entry_single_line_set(entry, EINA_TRUE);
	elm_entry_editable_set(entry, EINA_TRUE);
	elm_entry_magnifier_disabled_set(entry, EINA_TRUE);
	elm_entry_input_panel_enabled_set(entry, EINA_FALSE);
	evas_object_size_hint_weight_set(entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
	evas_object_size_hint_align_set(entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
	elm_object_content_set(scroller, entry);
	dial_d->entry = entry;

	evas_object_smart_callback_add(entry, "cursor,changed", dialer_entry_cursor_changed, dial_d);
	evas_object_smart_callback_add(entry, "changed", dialer_entry_text_changed, dial_d);
	evas_object_event_callback_add(entry, EVAS_CALLBACK_MOUSE_UP, dialer_entry_mouse_up, dial_d);
}

static void dialer_entry_number_init(void *data)
{
	PH_FN_CALL;
	int ret;
	char *buf;
	int value;
	char num[PH_TEXT_MAX_LEN] = {0};
	ph_dialer_data *dial_d = data;

	p_retm_if(PH_DAILER_EMERGENCY == dial_d->run_mode, "It is Emergency mode");

	value = FALSE;
	ret = vconf_get_bool(VCONFKEY_CISSAPPL_PREFIX_DIAL_BOOL, &value);

	if(dial_d->init_text) {
		ph_dialer_util_append_node_from_numstr_with_strip(dial_d, dial_d->init_text);
		ph_dialer_util_add_dashes(dial_d, DASH_REAL);
		ph_dialer_util_get_numstr_from_node(dial_d, num);
		ph_dialer_entry_set_number(dial_d, num, CURSOR_END, TRUE);
	}
	else if (value == TRUE) {
		ret = vconf_get_int(VCONFKEY_CISSAPPL_PREFIX_DIAL_VALUE_INT, &value);
		PH_DBG("prefix dial index: %d", value);
		buf = NULL;
		switch (value) {
		case 0:
			buf = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM1_STR);
			break;
		case 1:
			buf = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM2_STR);
			break;
		case 2:
			buf = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM3_STR);
			break;
		case 3:
			buf = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM4_STR);
			break;
		case 4:
			buf = vconf_get_str(VCONFKEY_CISSAPPL_PREFIX_DIAL_NUM5_STR);
			break;
		default:
			PH_DBG("wrong prefix index(%d)", value);
			break;
		}

		if (buf && *buf) {
			ph_dialer_util_append_node_from_numstr_with_strip(dial_d, buf);
			ph_dialer_util_add_dashes(dial_d, DASH_REAL);
			ph_dialer_util_get_numstr_from_node(dial_d, num);
			ph_dialer_entry_set_number(dial_d, num, CURSOR_END, TRUE);
			free(buf);
		}
	}
	else
		dialer_entry_set_number_noresize(dial_d, "");
	dial_d->initialized = TRUE;
}

static void dialer_lazy_init(void *data)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d = data;

	dialer_create_entry(dial_d);

	dial_d->entry_font_size = MAX_DIAL_NUMBER_FONT_SIZE;
	dial_d->number_cursor = &(dial_d->number_head);

	edje_object_signal_callback_add(_EDJ(dial_d->layout), "pad_clicked", "*", dialer_keypad_clicked, dial_d);
	edje_object_signal_callback_add(_EDJ(dial_d->layout), "pad_down", "*", dialer_keypad_down, dial_d);
	edje_object_signal_callback_add(_EDJ(dial_d->layout), "pad_up", "*", dialer_keypad_up, dial_d);
	edje_object_signal_callback_add(_EDJ(dial_d->layout), "softkey_clicked", "*", dialer_softkey_clicked, dial_d);
	edje_object_signal_callback_add(_EDJ(dial_d->layout), "softkey_up", "*", dialer_softkey_up, dial_d);
	edje_object_signal_callback_add(_EDJ(dial_d->layout), "softkey_down", "*", dialer_softkey_down, dial_d);

	dial_d->job = ecore_job_add(dialer_entry_number_init, dial_d);
}

static void dialer_layout_flush_post_cb(void *data, Evas *e, void *event_info)
{
	ph_dialer_data *dial_d = data;
	evas_event_callback_del(evas_object_evas_get(dial_d->layout),
		EVAS_CALLBACK_RENDER_FLUSH_POST, dialer_layout_flush_post_cb);
	dial_d->job = ecore_job_add(dialer_lazy_init, dial_d);
}

static void dialer_back_btn_cb(void *data, Evas_Object *obj, void *event_info)
{
	ph_dialer_data *dial_d = data;
	dial_d->initialized = FALSE;
	ph_dialer_util_entry_clear(dial_d);
}

int ph_dialer_create_content(ph_dialer_data *dial_d)
{
	PH_FN_CALL;
	dial_d->layout = elm_layout_add(dial_d->navi);
	p_retvm_if(NULL == dial_d->layout, 0, "elm_layout_add() Failed");
	elm_layout_file_set(dial_d->layout, DIALER_EDJ, "dialer/main");
	evas_object_size_hint_weight_set(dial_d->layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);

	if (dial_d->is_emergency)
		dial_d->run_mode = PH_DAILER_EMERGENCY;
	else
		dial_d->run_mode = PH_DAILER_NORMAL;
	ph_dialer_util_setup_run_mode(dial_d);

	edje_object_signal_emit(_EDJ(dial_d->layout), "main/default", "main");

	evas_object_data_set(dial_d->layout, KEY_DIALER_DATA, dial_d);

	evas_object_event_callback_add(dial_d->layout, EVAS_CALLBACK_DEL,
			dialer_view_delete_cb, dial_d);

	evas_event_callback_add(evas_object_evas_get(dial_d->layout),
		EVAS_CALLBACK_RENDER_FLUSH_POST, dialer_layout_flush_post_cb, dial_d);
	return 1;
}

API void phone_dialer_set_navi(Evas_Object *layout)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d;
	Evas_Object *cbar;
	Evas_Object *l_btn;
	Elm_Object_Item *navi_it;
	dial_d = evas_object_data_get(layout, KEY_DIALER_DATA);
	p_retm_if(NULL == dial_d, "dialer data is null");
	navi_it = elm_naviframe_bottom_item_get(dial_d->navi);

	cbar = elm_object_item_part_content_get(navi_it, "controlbar");
	if (cbar)
		phone_cbar_item_clear(cbar);

	if (!dial_d->ug) {
		l_btn = elm_button_add(dial_d->navi);
		evas_object_smart_callback_add(l_btn, "clicked", dialer_back_btn_cb, dial_d);
		evas_object_smart_callback_add(l_btn, "clicked", phone_back_btn_clicked_cb, dial_d ->win);
		elm_object_style_set(l_btn, "naviframe/back_btn/default");
	}
	else {
		l_btn = phone_naviframe_btn(dial_d->navi, S_(PH_SYS_SK_CANCEL));
		evas_object_smart_callback_add(l_btn, "clicked", phone_ug_destroy_me_cb, dial_d->ug);
	}
	elm_object_item_part_content_set(navi_it, "prev_btn", l_btn);
}

API void phone_dialer_view_reset(Evas_Object *layout)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d;
	Elm_Object_Item *item;

	dial_d = evas_object_data_get(layout, KEY_DIALER_DATA);
	p_retm_if(NULL == dial_d, "dialer data is null");

	if (!dial_d->ug) {
		Evas_Object *back_btn;
		Elm_Object_Item *navi_it = elm_naviframe_bottom_item_get(dial_d->navi);
		back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
		if(back_btn)
			evas_object_smart_callback_del(back_btn, "clicked", dialer_back_btn_cb);
	}

	item = elm_naviframe_bottom_item_get(dial_d->navi);
	if (elm_naviframe_top_item_get(dial_d->navi) != item)
		elm_naviframe_item_pop_to(item);
}

API void phone_dialer_check_focus(Evas_Object *layout)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d;
	char *text;

	dial_d = evas_object_data_get(layout, KEY_DIALER_DATA);
	p_retm_if(NULL == dial_d, "dialer data is null");

	text = elm_entry_markup_to_utf8(elm_entry_entry_get(dial_d->entry));

	if (dial_d->has_focus && text && dialer_include_zero_space(text) == -1)
		elm_object_focus_set(dial_d->entry, EINA_TRUE);
	else {
		elm_object_focus_set(dial_d->entry, EINA_FALSE);
		dial_d->has_focus = false;
	}
	free(text);
}

API void phone_dialer_view_resume(Evas_Object *layout)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d;
	dial_d = evas_object_data_get(layout, KEY_DIALER_DATA);
	p_retm_if(NULL == dial_d, "dialer data is null");

	if (!dial_d->initialized)
		dialer_entry_number_init(dial_d);
}

API void phone_dialer_view_set_num(Evas_Object *layout, char *number)
{
	PH_FN_CALL;
	ph_dialer_data *dial_d;
	char dest[PH_TEXT_MAX_LEN] = {0};
	dial_d = evas_object_data_get(layout, KEY_DIALER_DATA);
	p_retm_if(NULL == dial_d, "dialer data is null");

	if(dial_d->entry) {
		ph_dialer_util_append_node_from_numstr_with_strip(dial_d, number);
		ph_dialer_util_add_dashes(dial_d, DASH_REAL);
		ph_dialer_util_get_numstr_from_node(dial_d, dest);
		ph_dialer_entry_set_number(dial_d, dest, CURSOR_END, TRUE);
	}
	else
		dial_d->init_text = SAFE_STRDUP(number);
}