#include "MMI_features.h"
#ifdef __TOPWELL_MMI_SOS_INTEGRATION__//added by wm 
#include "fseditorcuigprot.h"
#include "GlobalResDef.h"
#include "GlobalConstants.h"
#include "SosIntegration.h"
#include "wgui_softkeys.h"
#include "mmi_rp_app_sos_integration_def.h"
#include "CommonScreens.h"
#include "UcmGProt.h"
#include "TimerEvents.h"
#include "SmsSrvGprot.h"
#include "NwInfoSrvGprot.h"
#include "InlineCuiGprot.h"
#include "CommonScreensResDef.h"
#include "stdlib.h"
#include "kal_release.h"
#include "stdio.h"
#include "string.h"
#include "PhbCuiGprot.h"



static srv_sos_integration_struct g_srv_sos_cntx;
srv_sos_integration_struct *srv_sos_cntx = &g_srv_sos_cntx;
static mmi_sos_cntx_struct g_srv_sos_info;
extern void mmi_ucm_in_call_endkey(void);
void mmi_sos_send_message(void);
void mmi_sos_redial_handle(void);


/****************************************************************************
 * Global context
 ****************************************************************************/
 
/* Emergency call buffer*/
U16 g_sos_number_buff[SRV_SOS_MAX_NUM_URI_LEN] = {0};

/* Call times,if make call failure,then plus 1,util call success */
U8 g_sos_call_times = 0;

/* Call failure or not */
U8 g_sos_call_status_flag = 0;

/* Play tone failure or not */
U8 g_sos_play_tone_flag = 0;

/* Send sms counter */
U8 g_sos_send_sms_counter = 0;

/* Is sos call or not */
MMI_BOOL g_is_sos_call_flag = MMI_FALSE;

/* Sens sms failure or not */
MMI_BOOL g_sos_send_sms_status_flag = MMI_FALSE;

/****************************************************************************
 * Functions
 ****************************************************************************/
void srv_mmi_sos_init(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/
	S16 error;
	//U16 sms_buff[]= L"I was in danger,please help me!";
	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	ReadValue(NVRAM_ID_SOS_MODE,&srv_sos_cntx->statu,DS_BYTE,&error);
	
	ReadRecord(NVRAM_EF_SOS_SETTINGS_LID, 1, &g_srv_sos_info, sizeof(mmi_sos_cntx_struct), &error);
	
	if(srv_sos_cntx->statu == 0xFF)
	{
		srv_sos_cntx->statu = 0;
		WriteValue(NVRAM_ID_SOS_MODE,&srv_sos_cntx->statu,DS_BYTE,&error);
	}
	
	if(g_srv_sos_info.sms_content[0]==0)
	{
		mmi_ucs2ncpy((CHAR*)g_srv_sos_info.sms_content, (CHAR*)get_string(STR_ID_SOS_SMS_CONTENT2), SRV_SOS_MAX_NUM_URI_LEN);
		WriteRecord(NVRAM_EF_SOS_SETTINGS_LID, 1, &g_srv_sos_info, sizeof(mmi_sos_cntx_struct), &error);
	}

}

static void mmi_hilite_sos_mode(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/

	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	if(srv_sos_cntx->statu==0)
		cui_menu_set_item_hint(srv_sos_cntx->menu_cui_id, MENU_ID_SOS_INTEGRATION_MODE, (WCHAR*)get_string(STR_GLOBAL_OFF));
	else
		cui_menu_set_item_hint(srv_sos_cntx->menu_cui_id, MENU_ID_SOS_INTEGRATION_MODE, (WCHAR*)get_string(STR_GLOBAL_ON));
}

static void mmi_set_sos_statu(U8 statu)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/
	S16 error;
	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
	srv_sos_cntx->statu = statu;
	
	WriteValue(NVRAM_ID_SOS_MODE,&srv_sos_cntx->statu,DS_BYTE,&error);
}


static mmi_ret mmi_sos_number_list_proc(mmi_event_struct *evt)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    switch (evt->evt_id)
    {
        /* screen event */
        case EVT_ID_SCRN_DEINIT:
            srv_sos_cntx->number_list_index = 0;
            MMI_ASSERT(evt->user_data);
            OslMfree(evt->user_data);
            break;

        default:
            break;
    }

    return MMI_RET_ALLOW_CLOSE;
}


static void mmi_sos_hilite_number(S32 index)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    srv_sos_cntx->number_list_index = index;
}


static void srv_sos_number_list_get_item(srv_sos_number_item_struct *item)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (item)
    {
        memset(item->number, 0, sizeof(item->number));
    }
    else
    {
        return;
    }

    if (item->index >= SRV_SOS_NUMBER_MAX_ITEM)
    {
        return;
    }
    mmi_ucs2ncpy((CHAR*)(item->number), (CHAR*)(g_srv_sos_info.number[item->index]), SRV_SOS_MAX_NUM_URI_LEN);
}



static void srv_sos_numberlist_set_number(srv_sos_number_item_struct *item)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S16 error;
    U32 i;
	srv_sos_number_item_struct temp_item;
	CHAR asc_num_buff[SRV_SOS_MAX_NUM_URI_LEN + 1];
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (!item ||(item->index >= SRV_SOS_NUMBER_MAX_ITEM))
    {
        return;
    }
	
    memset(asc_num_buff, 0, sizeof(asc_num_buff));
    mmi_ucs2_n_to_asc((CHAR*)asc_num_buff, (CHAR*)item->number, SRV_SOS_MAX_NUM_URI_LEN * ENCODING_LENGTH);
	
	if (mmi_ucs2strlen((CHAR*)item->number))
	{
        if (!srv_ucm_is_valid_number((srv_ucm_call_type_enum)SRV_UCM_CALL_TYPE_ALL, (PU8)asc_num_buff))
        {
            return;
        }
	
	    for (i = 0; i < SRV_SOS_NUMBER_MAX_ITEM; i++)
	    {
	        temp_item.index = i;
			srv_sos_number_list_get_item(&temp_item);

	        if (srv_phb_compare_number(temp_item.number, item->number))
	        {
	        	mmi_display_popup((UI_string_type)GetString(STR_ID_S0S_NUMBER_EXIST),MMI_EVENT_FAILURE);
	            return ;
	        }
	    }
	}	

    if (mmi_ucs2ncmp((CHAR*)g_srv_sos_info.number[item->index], (CHAR*)item->number, SRV_SOS_MAX_NUM_URI_LEN))
    {
        mmi_ucs2ncpy((CHAR*)g_srv_sos_info.number[item->index], (CHAR*)item->number, SRV_SOS_MAX_NUM_URI_LEN);
        WriteRecord(NVRAM_EF_SOS_SETTINGS_LID, 1, &g_srv_sos_info, sizeof(mmi_sos_cntx_struct), &error);
    }
}


static void mmi_sos_number_list_edit_done(MMI_ID gid)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    srv_sos_number_item_struct item;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	memset(item.number, 0, sizeof(item.number));
	cui_fseditor_get_text(gid, item.number, sizeof(item.number));
	item.index = srv_sos_cntx->number_list_index;
	srv_sos_numberlist_set_number(&item);
    mmi_display_popup((UI_string_type)GetString(STR_GLOBAL_SAVED),MMI_EVENT_SUCCESS);
	cui_fseditor_close(gid);
}


static void mmi_sos_entry_number_list_edit(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
	MMI_ID grp_id;
	srv_sos_number_item_struct item;
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
	grp_id = cui_fseditor_create(GRP_ID_SOS_INTEGRATION);
	srv_sos_cntx->number_edit_gid = grp_id;

	item.index = (U8)srv_sos_cntx->number_list_index;

	srv_sos_number_list_get_item(&item);

	cui_fseditor_set_text(grp_id, item.number, sizeof(item.number), SRV_SOS_MAX_NUM_URI_LEN - 1);
	cui_fseditor_set_title(grp_id, STR_GLOBAL_EDIT, NULL);
	cui_fseditor_set_input_method(grp_id, INPUT_TYPE_PLUS_CHARACTER_HANDLING|IMM_INPUT_TYPE_PHONE_NUMBER, NULL, 0);
	cui_fseditor_run(grp_id);
}


static void mmi_sos_number_list_add_from_contacts(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
	
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
	srv_sos_cntx->phb_select_grp_id = cui_phb_list_select_contact_create(GRP_ID_SOS_INTEGRATION);
	if (srv_sos_cntx->phb_select_grp_id!= GRP_ID_INVALID)
	{
		cui_phb_list_select_contact_set_field_filter(srv_sos_cntx->phb_select_grp_id, SRV_PHB_ENTRY_FIELD_GSM_NUM);
		cui_phb_list_select_contact_run(srv_sos_cntx->phb_select_grp_id);
	}
}


static void mmi_sos_entry_number_list(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables                                                */
	/*----------------------------------------------------------------*/
    U8 i;
    U8 *guiBuffer;
	srv_sos_number_item_struct item;
	PU8 string_list[SRV_SOS_NUMBER_MAX_ITEM];
	/*----------------------------------------------------------------*/
	/* Code Body                                                      */
	/*----------------------------------------------------------------*/
    if (!mmi_frm_scrn_enter(
        GRP_ID_SOS_INTEGRATION, 
        SCR_ID_SOS_NUMBER_LIST, 
        NULL, 
        mmi_sos_entry_number_list, 
        MMI_FRM_UNKNOW_SCRN))
    {
        mmi_frm_scrn_set_leave_proc(GRP_ID_SOS_INTEGRATION, SCR_ID_SOS_NUMBER_LIST, mmi_sos_number_list_proc);
        return;
    }

    memset(string_list, 0, sizeof(string_list));
	
    for (i = 0; i < SRV_SOS_NUMBER_MAX_ITEM; i++)
    {
        item.index = i;
        srv_sos_number_list_get_item(&item);
        memcpy(g_srv_sos_info.number[i], item.number, sizeof(item.number));
        string_list[i] = (PU8)(g_srv_sos_info.number[i]);
    }

	RegisterHighlightHandler(mmi_sos_hilite_number);
	guiBuffer = mmi_frm_scrn_get_active_gui_buf();

	ShowCategory84Screen(
		STR_ID_SOS_NUMBER_LIST,
		NULL,
		STR_GLOBAL_EDIT,
		0,
		STR_GLOBAL_BACK,
		IMG_GLOBAL_BACK,
		SRV_SOS_NUMBER_MAX_ITEM,
		string_list,
		(U16*)gIndexIconsImageList,
		0,
		srv_sos_cntx->number_list_index,
		guiBuffer);

	SetLeftSoftkeyFunction(mmi_sos_entry_number_list_edit, KEY_EVENT_UP);
	ChangeCenterSoftkey(0, IMG_GLOBAL_COMMON_CSK);
	SetCenterSoftkeyFunction(mmi_sos_number_list_add_from_contacts, KEY_EVENT_UP);
}


static void cui_sos_play_tone_callback(mdi_result result, void *user_data)
{
    if (result == MDI_AUDIO_TERMINATED)
    {
       g_sos_play_tone_flag = 0;
    }
}
#if 1//def __TOPWELL_HW_TORCH_TYPE_SOS__
static void mmi_sos_play_ring_tone(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8          audio_type;
    U32         audio_len;  
    U8 *        audio_data;
    mdi_result  result;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	audio_data = (U8 *)get_audio(AUD_ID_SOS_RING, &audio_type, &audio_len);
	
	if (audio_data == NULL || srv_prof_is_profile_activated(SRV_PROF_SILENT_MODE)==SRV_PROF_RET_PROFILE_ACTIVATED)
	{
		return;
	}
	result = mdi_audio_play_string_with_vol_path(
				   (void*)audio_data,
				   audio_len,
				   audio_type,
				   DEVICE_AUDIO_PLAY_ONCE,
				   cui_sos_play_tone_callback,
				   NULL,
				   MDI_AUD_VOL_6,
				   MDI_DEVICE_SPEAKER2);

	if (result == MDI_AUDIO_SUCCESS)
	{
		kal_prompt_trace(MOD_VT,"mmi_sos_play_ring_tone->succeed");
	    g_sos_play_tone_flag = 1;
	}
}

static void mmi_sos_blink_torch(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef __MTK_TARGET__
    torch_switch();
#endif
    StopTimer(TIMER_ID_SOS_BLINK_TORCH);
    StartTimer(TIMER_ID_SOS_BLINK_TORCH, 300, mmi_sos_blink_torch);
}
#endif
MMI_BOOL IsSosCall(void) 
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	MMI_BOOL result;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	if(g_is_sos_call_flag)
	{
		result = MMI_TRUE;
	}
	else
	{
		result = MMI_FALSE;
	}
		
	return result;
}


void mmi_sos_release_call_ind(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	g_is_sos_call_flag = 0;
	kal_prompt_trace(MOD_VT,"mmi_sos_release_call_ind->0");
#ifdef __TOPWELL_HW_TORCH_TYPE_SOS__
	if(IsMyTimerExist(TIMER_ID_SOS_BLINK_TORCH))
	{
		StopTimer(TIMER_ID_SOS_BLINK_TORCH);
	#ifdef __MTK_TARGET__
		topwell_torch_off();
	#endif
		mdi_audio_stop_all();
		kal_prompt_trace(MOD_VT,"mmi_sos_release_call_ind->1");
	}
 #endif
	if(g_sos_call_status_flag)
	{
		g_sos_call_status_flag = 0;
		if(IsMyTimerExist(TIMER_ID_SOS_CALL_TIME_OUT))
		{
			StopTimer(TIMER_ID_SOS_CALL_TIME_OUT);
		}
		if(IsMyTimerExist(TIMER_ID_SOS_REDIAL))
		{	
			StopTimer(TIMER_ID_SOS_REDIAL);
		}	
		if(IsMyTimerExist(TIMER_ID_SOS_RING))
		{	
			StopTimer(TIMER_ID_SOS_RING);
		}	
		kal_prompt_trace(MOD_VT,"mmi_sos_release_call_ind->2");
	}
	else
	{
		kal_prompt_trace(MOD_VT,"mmi_sos_release_call_ind->3");
		g_sos_call_times += 1;
		if(g_sos_call_times >= SRV_SOS_NUMBER_MAX_ITEM)
		{
			g_sos_call_times = 0;
		}
		StartTimer(TIMER_ID_SOS_REDIAL, SRV_SOS_REDIAL_DURATION, mmi_sos_redial_handle);
	}
}


mmi_sos_cntx_struct *srv_sos_get_cntx(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    return &g_srv_sos_info;
}


void mmi_sos_get_gps_infomation(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	
	/* Keep GPS interface */

}


static void mmi_sos_analysis_sms_content(U16 *content)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	char *pstr_num,*pstr1,*pstr2;
	char g_sms_asc_buff[SRV_SOS_MAX_NUM_URI_LEN];
	U8 theloop = 0;
	S16 error;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	memset(g_sms_asc_buff,0,SRV_SOS_MAX_NUM_URI_LEN);
	mmi_ucs2_to_asc((CHAR *)g_sms_asc_buff,(CHAR *)content);
	pstr1 = strstr(g_sms_asc_buff,SRV_SOS_SMS_CNTX_HEADER);
	if(pstr1==NULL)
	{
		return;
	}
	pstr_num = g_sms_asc_buff+strlen(SRV_SOS_SMS_CNTX_HEADER);
	pstr2 = strchr(pstr_num,'#');
	*pstr2 = 0;

	while(theloop<SRV_SOS_NUMBER_MAX_ITEM)
	{
		if(g_srv_sos_info.number[theloop][theloop]==0)
		{
			mmi_asc_to_ucs2((CHAR *)g_srv_sos_info.number[theloop],(CHAR *)(pstr_num));
			WriteRecord(NVRAM_EF_SOS_SETTINGS_LID, 1, &g_srv_sos_info, sizeof(mmi_sos_cntx_struct), &error);
			break;
		}
		theloop++;
	}
}


void mmi_sos_compare_sms_content(U16 *content,U16 *l4_number)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U16 sms_asc_num_buff[SRV_SMS_MAX_ADDR_LEN + 1];
	int i;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	mmi_asc_to_ucs2((CHAR *) sms_asc_num_buff, (CHAR *) l4_number);
	for(i=0;i<SRV_SOS_NUMBER_MAX_ITEM;i++)
	{
		if(mmi_ucs2cmp((const char *)g_srv_sos_info.number[i], (const char *)sms_asc_num_buff) == 0)
		{
			mmi_sos_analysis_sms_content(content);
		}
	}
}


MMI_BOOL IsNumNULL(void)
{
U32 i;
MMI_BOOL g_sos_num_null = FALSE;
for(i=0;i<SRV_SOS_NUMBER_MAX_ITEM;i++)
{
	if(mmi_ucs2cmp((const char *)g_srv_sos_info.number[i], (const char *)"") == 0)
	{
		g_sos_num_null = TRUE;
		
	}
	else
	{
	  g_sos_num_null = FALSE;
	  break;
	}	
}
return g_sos_num_null;

}

static void mmi_sos_make_call_prepare(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	mmi_ucs2ncpy((CHAR*)g_sos_number_buff, 
		(CHAR*)g_srv_sos_info.number[g_sos_call_times], 
		SRV_SOS_MAX_NUM_URI_LEN);
	mmi_sos_send_message();
	//kal_prompt_trace(MOD_VT,"mmi_sos_make_call_prepare");
}

void mmi_sos_make_call_entry(U16 *number)
{
	/*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_ucm_make_call_para_struct make_call_para;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/	    

	//if (g_sos_number_buff[g_sos_call_times]==0)
	if (number[0] == 0) //(strlen(g_sos_number_buff) == 0)
	{
        mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_INVALID_NUMBER),MMI_EVENT_FAILURE);
		g_sos_call_times+=1;
		StartTimer(TIMER_ID_SOS_REDIAL, SRV_SOS_REDIAL_DURATION, mmi_sos_redial_handle);
		kal_prompt_trace(MOD_VT,"mmi_sos_make_call->>0");
        return;
	}

    mmi_ucm_init_call_para(&make_call_para);
    make_call_para.adv_para.after_make_call_callback = NULL; 

	if(srv_sim_ctrl_is_available(MMI_SIM1) && !srv_sim_ctrl_is_available(MMI_SIM2))
	{
		make_call_para.dial_type = SRV_UCM_VOICE_CALL_TYPE;
	}
	else if(!srv_sim_ctrl_is_available(MMI_SIM1) && srv_sim_ctrl_is_available(MMI_SIM2))
	{
		make_call_para.dial_type = SRV_UCM_VOICE_CALL_TYPE_SIM2;	
	}
	else
	{
		/* if dual sim available, default sim1 call directly, don't do the choose action */
		make_call_para.dial_type = SRV_UCM_VOICE_CALL_TYPE; 
	}
	
    make_call_para.ucs2_num_uri = (U16*)number;
#ifdef __TOPWELL_HW_TORCH_TYPE_SOS__
	/* play sos ring */
	mmi_sos_play_ring_tone();

	/* blink torch */
	mmi_sos_blink_torch();
#endif
   
	g_is_sos_call_flag = 1;

    mmi_ucm_call_launch(0, &make_call_para);	
}



void mmi_sos_make_call(void)
{
	/*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    mmi_ucm_make_call_para_struct make_call_para;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	if(!srv_sos_cntx->statu)
	{
        mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_CURRENTLY_NOT_AVAILABLE),MMI_EVENT_FAILURE);
        return;
	}
    if (!srv_sim_ctrl_is_available(MMI_SIM1) && !srv_sim_ctrl_is_available(MMI_SIM2))
    {
    	mmi_ucs2ncpy((CHAR*)g_sos_number_buff, (CHAR*)L"112", SRV_SOS_MAX_NUM_URI_LEN);
        //mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_INSERT_SIM_CARD),MMI_EVENT_FAILURE);
        //return;
    }
	else if(IsNumNULL())
	{
		mmi_display_popup((UI_string_type)get_string(STR_ID_SOS_NUMBER_LIST2),MMI_EVENT_FAILURE);
		return;
	}
	else
	{
		mmi_sos_make_call_prepare();	
	}
	
	mmi_sos_make_call_entry(g_sos_number_buff);	
}


void mmi_sos_redial_handle(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	mmi_sos_make_call();
}


void mmi_sos_start_launch(void)
{
	g_sos_call_times = 0;
	memset(g_sos_number_buff, 0, SRV_SOS_MAX_NUM_URI_LEN); 
	ClearKeyHandler(KEY_ENTER, KEY_EVENT_UP);
	   /* play sos ring */
	mmi_sos_play_ring_tone();
	StartTimer(TIMER_ID_SOS_RING, SRV_SOS_RING_DURATION, mmi_sos_make_call);
	//mmi_sos_make_call();	
}


static void srv_sos_send_sms_callback(srv_sms_callback_struct* callback_data)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

	if (callback_data->result == MMI_TRUE)
	{
		/*send succeed*/
		g_sos_send_sms_status_flag = MMI_TRUE;
		if(IsMyTimerExist(TIMER_ID_SOS_SEND_SMS))
		{	
			StopTimer(TIMER_ID_SOS_SEND_SMS);
		}
		if(IsMyTimerExist(TIMER_ID_SOS_REDIAL))
		{	
			StopTimer(TIMER_ID_SOS_REDIAL);
		}
		if(IsMyTimerExist(TIMER_ID_SOS_RING))
		{	
			StopTimer(TIMER_ID_SOS_RING);
		}
		kal_prompt_trace(MOD_VT,"srv_sos_send_sms_callback->succed");
	}
	else
	{
		/*send failure*/
		g_sos_send_sms_status_flag = MMI_FALSE;	
	}
}


static void mmi_sos_send_message_api(mmi_sim_enum sim, S8 * content, S8 *ucs2_addr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	SMS_HANDLE srv_send_handle;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	kal_prompt_trace(MOD_VT,"mmi_sos_send_message_api->>0");
	srv_send_handle = srv_sms_get_send_handle();
	
	if(srv_send_handle == NULL)
	{
		return;
	}
	kal_prompt_trace(MOD_VT,"mmi_sos_send_message_api->>1");

	srv_sms_set_address(srv_send_handle, ucs2_addr);
#ifdef __UNIFIED_MESSAGE_BACKGROUND_SEND_SUPPORT__
	srv_sms_set_send_type(srv_send_handle, SRV_SMS_BG_SEND);
#endif
	srv_sms_set_content_dcs(srv_send_handle, SRV_SMS_DCS_UCS2);

	srv_sms_set_content(srv_send_handle, (S8*)content, app_ucs2_strlen((kal_int8*)content) * 2);

	if(sim == MMI_SIM1)
	{
		kal_prompt_trace(MOD_VT,"mmi_sos_send_message_api->>2");
		srv_sms_set_sim_id(srv_send_handle, SRV_SMS_SIM_1); 
	}
	else if(sim == MMI_SIM2)
	{
		kal_prompt_trace(MOD_VT,"mmi_sos_send_message_api->>3");
		srv_sms_set_sim_id(srv_send_handle, SRV_SMS_SIM_2); 
	}

	srv_sms_send_msg(srv_send_handle, srv_sos_send_sms_callback, NULL);
}


void mmi_sos_send_message(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
	srv_nw_info_service_availability_enum state;
	S8 ucs2_addr[(SRV_SOS_MAX_NUM_URI_LEN + 1) * ENCODING_LENGTH]={0};
	U8 sms_buff[SRV_SOS_SMS_CONTENT_LENGTH]={0};
	U8 sms_temp[SRV_SOS_SMS_CONTENT_LENGTH]= {0};
	U8 theloop = 0;
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
	kal_prompt_trace(MOD_VT,"mmi_sos_send_message->>0");
	
	if(IsMyTimerExist(TIMER_ID_SOS_SEND_SMS))
	{	
		StopTimer(TIMER_ID_SOS_SEND_SMS);
	}

	if(MMI_FALSE == mmi_sms_is_sms_ready())
	{
		StartTimer(TIMER_ID_SOS_SEND_SMS, SRV_SOS_SEND_SMS_TIME_DURATION, mmi_sos_send_message);
		return;
	}


	mmi_ucs2ncpy((CHAR*)ucs2_addr, (CHAR*)g_srv_sos_info.number[g_sos_call_times], SRV_SOS_MAX_NUM_URI_LEN);

	
	kal_prompt_trace(MOD_VT,"mmi_sos_send_message->>g_srv_sos_info.number:%s",ucs2_addr);

	if(g_srv_sos_info.my_number[0]!=0)
	{
		mmi_ucs2cat((CHAR *)sms_temp,(CHAR *)GetString(STR_ID_S0S_MY_NUMBER_HEADER));
		mmi_ucs2cat((CHAR *)sms_temp,(CHAR *)g_srv_sos_info.my_number);		
		mmi_ucs2cat((CHAR *)sms_temp,(CHAR *)L"\n");
		mmi_ucs2cat((CHAR *)sms_temp,(CHAR *)GetString(STR_ID_SOS_SMS_CONTENT2));
		mmi_ucs2cpy((CHAR *)sms_buff,(CHAR *)sms_temp);
	}
	else
	{
		mmi_ucs2cpy((CHAR *)sms_buff,(CHAR *)GetString(STR_ID_SOS_SMS_CONTENT2));
	}
		
	if(SRV_NW_INFO_SA_FULL_SERVICE == srv_nw_info_get_service_availability(MMI_SIM1))
	{	      
		mmi_sos_send_message_api(MMI_SIM1,(S8 *)sms_buff,ucs2_addr);
		kal_prompt_trace(MOD_VT,"mmi_sos_send_message->>1 ");
	}
	else if(SRV_NW_INFO_SA_FULL_SERVICE == srv_nw_info_get_service_availability(MMI_SIM2))
	{
		mmi_sos_send_message_api(MMI_SIM2,(S8 *)sms_buff,ucs2_addr);
		kal_prompt_trace(MOD_VT,"mmi_sos_send_message->>2 ");
	}
	else if(SRV_NW_INFO_SA_FULL_SERVICE != srv_nw_info_get_service_availability(MMI_SIM2) && 
		SRV_NW_INFO_SA_FULL_SERVICE != srv_nw_info_get_service_availability(MMI_SIM1))
	{
		if( g_sos_send_sms_counter <= SRV_SOS_SEND_SMS_COUNT )
		{
			StartTimer(TIMER_ID_SOS_SEND_SMS, SRV_SOS_SEND_SMS_TIME_DURATION, mmi_sos_send_message);
			g_sos_send_sms_counter += 1; 
			kal_prompt_trace(MOD_VT,"mmi_sos_send_message->>3 ");
		}
		return;
	}
	
}


void mmi_sos_call_time_out_handle(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	if(!g_sos_call_status_flag)
	{
		if(SRV_IS_IN_CALL())
		{
			kal_prompt_trace(MOD_VT,"mmi_sos_call_time_out_handle->>0 ");
			mmi_ucm_outgoing_call_endkey();
		}

		if(IsMyTimerExist(TIMER_ID_SOS_CALL_TIME_OUT))
		{
			StopTimer(TIMER_ID_SOS_CALL_TIME_OUT);
			kal_prompt_trace(MOD_VT,"mmi_sos_call_time_out_handle->>1");
		}
	}
}

/****************************************************************************
 * Inline item data
 ****************************************************************************/
static const cui_inline_item_caption_struct sos_inline_edit_cap[2] = 
{
    STR_ID_S0S_MY_NUMBER, 
    STR_ID_SOS_SMS_CONTENT
};

static const cui_inline_item_text_edit_struct sos_inline_my_number_edit = 
{
    0, 
    0, 
    SRV_SOS_MAX_NUM_URI_LEN+1, 
    IMM_INPUT_TYPE_NUMERIC, 
    0, 
    NULL
};

static const cui_inline_item_text_edit_struct sos_inline_message_content_edit = 
{
    0, 
    0, 
    SRV_SOS_SMS_CONTENT_LENGTH+1, 
    IMM_INPUT_TYPE_SENTENCE, 
    0, 
    NULL
};

static const cui_inline_set_item_struct sos_inline_item[SOS_INLINE_MAX] = 
{
	{
		CUI_INLINE_ITEM_ID_BASE + SOS_MY_NUMBER, 
		CUI_INLINE_ITEM_TYPE_CAPTION, 
		IMG_GLOBAL_L1, 
		&sos_inline_edit_cap[0]
	},

	{
		CUI_INLINE_ITEM_ID_BASE + SOS_MY_NUMBER_EDIT, 
		CUI_INLINE_ITEM_TYPE_TEXT_EDIT, 
		0, 
		&sos_inline_my_number_edit
	},

	{
		CUI_INLINE_ITEM_ID_BASE + SOS_MESSAGE, 
		CUI_INLINE_ITEM_TYPE_CAPTION, 
		IMG_GLOBAL_L2, 
		&sos_inline_edit_cap[1]
	},

	{
		CUI_INLINE_ITEM_ID_BASE + SOS_MESSAGE_EDIT, 
		CUI_INLINE_ITEM_TYPE_TEXT_EDIT, 
		0, 
		&sos_inline_message_content_edit
	},
};


static const cui_inline_struct srv_sos_edit_inline_data = 
{
    SOS_INLINE_MAX,
    STR_ID_SOS_SETTINGS,
    0,
    0,
    NULL,
    sos_inline_item
};


static void mmi_sos_inline_item_save()
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
    S16 pError;
    U16 my_number_temp[SRV_SOS_MAX_NUM_URI_LEN+1] = {0};
    U16 sos_message_tmep[SRV_SOS_SMS_CONTENT_LENGTH+1] = {0};
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
	cui_inline_get_value(srv_sos_cntx->setting_grp_id, 
	                  CUI_INLINE_ITEM_ID_BASE + SOS_MY_NUMBER_EDIT, 
	                  my_number_temp);

	cui_inline_get_value(srv_sos_cntx->setting_grp_id, 
	                  CUI_INLINE_ITEM_ID_BASE + SOS_MESSAGE_EDIT, 
	                  sos_message_tmep);

	mmi_ucs2cpy((CHAR*)g_srv_sos_info.my_number, (const CHAR*)my_number_temp);
	mmi_ucs2cpy((CHAR*)g_srv_sos_info.sms_content, (const CHAR*)sos_message_tmep);

	if(WriteRecord(NVRAM_EF_SOS_SETTINGS_LID, 1, &g_srv_sos_info, sizeof(mmi_sos_cntx_struct), &pError))
	{
		cui_inline_close(srv_sos_cntx->setting_grp_id);
		mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_DONE), MMI_EVENT_SUCCESS);
	}
	else
	{
		mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_ERROR), MMI_EVENT_FAILURE);
	}
}




static mmi_ret mmi_sos_entry_setting_proc(mmi_event_struct* evt)
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
	cui_menu_event_struct *menu_evt = (cui_menu_event_struct *)evt;
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
	switch(evt->evt_id)
	{	 
	 case EVT_ID_CUI_MENU_LIST_ENTRY:
		break;
		
	case EVT_ID_CUI_MENU_LIST_EXIT:
		break;
		
	case EVT_ID_CUI_MENU_ITEM_HILITE:
		break;
		
	case EVT_ID_CUI_MENU_ITEM_SELECT:
	case EVT_ID_CUI_MENU_ITEM_TAP:
	case EVT_ID_CUI_MENU_ITEM_CSK_SELECT:		
		break;

		
	case EVT_ID_CUI_MENU_CLOSE_REQUEST:
		{
			cui_menu_close(menu_evt->sender_id);
		}
		break;
		
	case EVT_ID_POPUP_QUIT:
		if (evt->user_data != NULL)
		{
				U16 grp_id = *(U16 *)evt->user_data;
				mmi_frm_group_close(grp_id);
		}		 
		break;

	case EVT_ID_CUI_INLINE_MAIN_SCREEN_ACTIVE:
		break;

	case EVT_ID_CUI_INLINE_NOTIFY:
		break;

		
	case EVT_ID_CUI_INLINE_SUBMIT:
		{
			mmi_sos_inline_item_save();
			cui_inline_close(srv_sos_cntx->setting_grp_id);
		}
		break;
			
	case EVT_ID_CUI_INLINE_ABORT:
		{
			cui_inline_close(srv_sos_cntx->setting_grp_id);
		}
		break;
			
	case EVT_ID_CUI_INLINE_GROUP_DEINIT:
		break;

	default:
		break;
	}

	return MMI_RET_OK;
}




static void mmi_sos_entry_settings(void)
{
	/*----------------------------------------------------------------*/
	/* Local Variables												  */
	/*----------------------------------------------------------------*/
	
	/*----------------------------------------------------------------*/
	/* Code Body													  */
	/*----------------------------------------------------------------*/
    mmi_frm_group_create(GRP_ID_SOS_INTEGRATION, 
                          GRP_ID_SOS_SETTINGS, 
                          mmi_sos_entry_setting_proc, 
                          NULL);
    
    mmi_frm_group_enter(GRP_ID_SOS_SETTINGS, MMI_FRM_NODE_SMART_CLOSE_FLAG);
	
    srv_sos_cntx->setting_grp_id = cui_inline_create(GRP_ID_SOS_SETTINGS, &srv_sos_edit_inline_data);
	
	cui_inline_set_value(srv_sos_cntx->setting_grp_id, 
						CUI_INLINE_ITEM_ID_BASE + SOS_MY_NUMBER_EDIT, 
						g_srv_sos_info.my_number);
	cui_inline_set_value(srv_sos_cntx->setting_grp_id, 
						CUI_INLINE_ITEM_ID_BASE + SOS_MESSAGE_EDIT, 
						g_srv_sos_info.sms_content);

    cui_inline_run(srv_sos_cntx->setting_grp_id);
}



static mmi_ret mmi_sos_menu_proc(mmi_event_struct *evt)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
	cui_menu_event_struct *event = (cui_menu_event_struct *)evt;
    mmi_menu_id hilight_menu = event->highlighted_menu_id;
	cui_fseditor_evt_struct *fsedit_evt = (cui_fseditor_evt_struct*)evt;
	cui_phb_select_contact_result_struct *select_result;
	srv_sos_number_item_struct item;
    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
	switch(evt->evt_id)
	{
		case EVT_ID_CUI_MENU_LIST_ENTRY:
				mmi_hilite_sos_mode();
			break;

		case EVT_ID_CUI_MENU_LIST_EXIT:
			break;

		case EVT_ID_CUI_MENU_ITEM_SELECT:
			if (hilight_menu == MENU_ID_SOS_INTEGRATION_MODE)
			{
				if(srv_sos_cntx->statu==1)
				{
					mmi_set_sos_statu(0);
					mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_CLOSE),MMI_EVENT_INFO);
				}
				else
				{
					mmi_set_sos_statu(1);
					mmi_display_popup((UI_string_type)get_string(STR_GLOBAL_OPEN),MMI_EVENT_INFO);
				}
			}
			else if(hilight_menu == MENU_ID_SOS_NUMBER_LIST)
			{
				mmi_sos_entry_number_list();
			}
			else if(hilight_menu == MENU_ID_SOS_SMS_SETTINGS)
			{
				mmi_sos_entry_settings();
			}
			break;
			
		case EVT_ID_PHB_SELECT_CONTACT:
			select_result = (cui_phb_select_contact_result_struct*) evt;		  
			if(select_result->select_data !=NULL)
			{
				mmi_ucs2ncpy((CHAR*)(item.number), (CHAR*)select_result->select_data, SRV_SOS_MAX_NUM_URI_LEN);
				item.index = srv_sos_cntx->number_list_index; 
				srv_sos_numberlist_set_number(&item);
				cui_phb_list_select_contact_close(srv_sos_cntx->phb_select_grp_id);
			}		
		break;

		case EVT_ID_PHB_SELECT_CONTACT_CANCEL:
			break;		

			
		case EVT_ID_CUI_FSEDITOR_ABORT:
		case EVT_ID_CUI_FSEDITOR_DEINIT:
			{
				if(fsedit_evt->sender_id == srv_sos_cntx->number_edit_gid)
				{
					srv_sos_cntx->number_edit_gid = 0;
				}
				else if(fsedit_evt->sender_id == srv_sos_cntx->message_edit_gid)
				{
					srv_sos_cntx->message_edit_gid = 0;
				}
				
					cui_fseditor_close(event->sender_id);
			}
				break;
				
		case EVT_ID_CUI_FSEDITOR_CSK_PRESSED:
		case EVT_ID_CUI_FSEDITOR_SUBMMIT:
			{
				if(fsedit_evt->sender_id == srv_sos_cntx->number_edit_gid)
				{
					mmi_sos_number_list_edit_done(fsedit_evt->sender_id);
				}				
				cui_fseditor_close(event->sender_id);
			}
				break;

		case EVT_ID_CUI_MENU_CLOSE_REQUEST:
			{
				cui_menu_event_struct *event = (cui_menu_event_struct *)evt;
				cui_menu_close(event->sender_id);
			}
			break;

		case EVT_ID_GROUP_DEINIT:
			break;

		default:
		break;
	}
	return MMI_RET_OK;
}

void mmi_sos_launch_ext(MMI_ID parent_gid)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    mmi_frm_group_create(parent_gid, GRP_ID_SOS_INTEGRATION, mmi_sos_menu_proc, (void*)NULL);
	mmi_frm_group_enter(GRP_ID_SOS_INTEGRATION, MMI_FRM_NODE_SMART_CLOSE_FLAG);

	srv_sos_cntx->menu_cui_id = cui_menu_create(
		GRP_ID_SOS_INTEGRATION, 
		CUI_MENU_SRC_TYPE_RESOURCE, 
		CUI_MENU_TYPE_APPSUB, 
		MENU_ID_SOS_INTEGRATION, 
		MMI_TRUE, 
		NULL);
    
	cui_menu_run(srv_sos_cntx->menu_cui_id);
}

mmi_ret mmi_shct_sos_key_menu_handler(cui_menu_event_struct *event, MMI_ID parent_gid)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (event->evt_id == EVT_ID_CUI_MENU_ITEM_SELECT &&
        event->highlighted_menu_id == MENU_ID_SOS_INTEGRATION)
    {
        mmi_sos_launch_ext(parent_gid);
        return MMI_RET_OK;
    }
    else
    {
        return MMI_RET_DONT_CARE;
    }
}

void mmi_sos_launch(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    mmi_frm_group_create(GRP_ID_ROOT, GRP_ID_SOS_INTEGRATION, mmi_sos_menu_proc, (void*)NULL);
	mmi_frm_group_enter(GRP_ID_SOS_INTEGRATION, MMI_FRM_NODE_SMART_CLOSE_FLAG);

	srv_sos_cntx->menu_cui_id = cui_menu_create(
		GRP_ID_SOS_INTEGRATION, 
		CUI_MENU_SRC_TYPE_RESOURCE, 
		CUI_MENU_TYPE_APPSUB, 
		MENU_ID_SOS_INTEGRATION, 
		MMI_TRUE, 
		NULL);
    
	cui_menu_run(srv_sos_cntx->menu_cui_id);
}

void HighLightSOS(void)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
    SetLeftSoftkeyFunction(mmi_sos_launch, KEY_EVENT_UP);
    SetRightSoftkeyFunction(mmi_frm_scrn_close_active_id, KEY_EVENT_UP);
    ChangeCenterSoftkey(0, IMG_GLOBAL_COMMON_CSK);
    SetCenterSoftkeyFunction(mmi_sos_launch, KEY_EVENT_UP);
}

#endif /*__TOPWELL_MMI_SOS_INTEGRATION__*/