mmimmstomobilesoft.c

是一个手机功能的模拟程序

#ifdef _MMS_ENABLE_

#define ENTITY_MFW

#include <string.h>
#include <stdio.h>

#if defined (NEW_FRAME)

    #include "typedefs.h"
    #include "vsi.h"
    #include "pei.h"
    #include "custom.h"
    #include "gsm.h"

#else

    #include "stddefs.h"
    #include "custom.h"
    #include "gsm.h"
    #include "vsi.h"

#endif

#include "p_sim.h"

#include "mfw_mfw.h"
#include "mfw_win.h"
#include "mfw_kbd.h"
#include "mfw_lng.h"
#include "mfw_edt.h"
#include "mfw_cm.h"
#include "mfw_phb.h"
#include "mfw_sms.h"
#include "mfw_icn.h"
#include "mfw_mnu.h"
#include "mfw_tim.h"
#include "mfw_sim.h"
#include "mfw_nm.h"
#include "mfw_sat.h"

#include "dspl.h"

#include "MmiMmi.h"

#include "MmiDummy.h"
#include "MmiDialogs.h"
#include "MmiLists.h"

#include "MmiMain.h"
#include "MmiStart.h"

#include "MmiMenu.h"

#include "MmiBookController.h"
#include "MmiBookUtils.h"

#include "MmiCall.h"
#include "MmiNetwork.h"
#include "MmiIcons.h"
#include "MmiEditor.h"


#include "MmiSounds.h"
#include "MmiUserData.h"
#include "MmiSoftKeys.h"
#include "MmiPins.h"

#include "MmiDialogs.h"
#include "MmiIdle.h"
#include "MmiNetwork.h"
#include "MmiSettings.h"
#include "MmiSmsIdle.h"
#include "mfw_ffs.h"
#include "MmiSmsBroadcast.h"
#include "MmiCPHS.h"
#ifdef MMI_HOMEZONE_ENABLED
    #include "MmiHomezone.h"
#endif

#include "mmimms_cfg.h"
#include "ffs.h" 
#include "mms_clib.h"
#include "wap_interface.h"
#include "td.h"
#include "mmsgloble.h"
#include "mmiMMSGlobalDef.h"
#include "Rtc_api.h"

//#include "Zi8api.h"
//#include "Rvf_api.h"
#ifndef _INNOVATION_EMULATOR_
#include "melody_cfg.h"
#include "melody_struct_i.h"
#include "melody_api.h"
#include "melody_env.h"
#endif

#include "mmimmsmenu.h"
#include "mmiutilapi.h"

#ifdef MMI_MMSTASK_ENABLED
#define MMS_COMPILE_FORAPP
#include "mmstask.h"
#include "mms_timer.h"
#endif

/* define for FFS files */ 
#define MMS_FILENAME_LEN		20
#define MMS_PATHNAME_LEN		20
#define MMS_FILEFULLNAME_LEN	(MMS_FILENAME_LEN + MMS_PATHNAME_LEN + 1)

#define MMS_TIMECRITICAL	1	/* Robert.Chen add, 2004-07-15 */

/*talcon add, 2004.07.07 */ 
static int g_codememalloc = 0;
#if 1
#define MMS_new(ptr, size)  		MI_ALLOC(ptr, size,g_codememalloc)
#define MMS_free(ptr,size)      	MI_FREE(ptr, g_codememalloc)
#else
#define MMS_new(ptr, size)  \
	ptr = (void *)mfwAlloc(size);\
	if(ptr ==0)\
		g_codememalloc  = 1;\
	else\
		g_codememalloc  = 0;
#define MMS_free(ptr,size)      			mfwFree((U8*)ptr, size)
#endif

/*end talcon add*/

BOOL isIncomingCall = FALSE;

#define TOLOWER(c) ((c) >= 'A' && (c) <= 'Z' ? (c) - 'A' + 'a' : (c))
#define UNI_TOLOWER(c)  ((c)>=0x41 &&(c)<=0x5a ? (c)+0x20 : (c))

extern void AscEx_To_Unicode(MMS_S8* ascEx_txt, MMS_S8* uni_txt);

//add by xie 04-07-31 for configuring the max size of mms file
#define MMS_MAX_SIZE    (1024*80) 
MMS_U32  MMS_Get_Maxsize()
{
	return MMS_MAX_SIZE;
}

//如字符串为空（NULL）返回0，否则返回字符串所占字节的个数，即对unicode除去头、尾三个字节，对ASCII出去尾一个字节
MMS_U32 MMS_strlen(const MMS_S8* str)
{	
#if (MMS_TIMECRITICAL == 0)
	return((MMS_U32)wstrlen(str));
#else
	unsigned int len = 0;
	
	if(!str)
		return 0;

	if((unsigned char)*str != 0x80)
	{
		while(*str++ != 0)
			len++;
	}
	else
	{
		str++;
		len++;

		while (((unsigned char)*str<<8)+(unsigned char)*(str+1) != 0)
		{
			len += 2;
			str += 2;
		}
	}

	return len;	
#endif
}

MMS_S8 *MMS_strstr(const MMS_S8 *str, const MMS_S8 *find)
{

	MMS_S32 len,lenth;
	MMS_S8 *point,*find2;
	MMS_S32 flag=0;
	
	
	if( (MMS_U8)*str != 0x80 && (MMS_U8)*find != 0x80 )
	{	
		return strstr(str, find);
	}
	else if((MMS_U8)*str == 0x80 && (MMS_U8)*find == 0x80)
	{
		len = MMS_strlen(find);
		if((MMS_U8)*find == 0x80)
			len -= 1;
			
		point = (MMS_S8 *)(str+1);  //用另外的指针指向当前的位置,str用来返回用的
		find2 = (MMS_S8 *)(find+1);
		lenth = len;
		while(lenth!=0)
		{
			if((MMS_S8)(*point) == (MMS_S8)(*find2))
			{
				lenth--;
				point++;
				find2++;
			}
			else
			{
				str++;
				point= (MMS_S8 *)str;
				find2= (MMS_S8 *)(find+1);
				lenth=len;
				if(1==flag&&0==*str)
					return NULL;
				if(0==*str)
				{
					flag=1;
				}else{
					flag=0;
				}			
			}
		}
		return (MMS_S8 *)str;		
	}
	else
		return NULL;

}

MMS_S8 *MMS_strcpy (MMS_S8 *dst,  const MMS_S8 *src)
{
#if (MMS_TIMECRITICAL == 0)
	if(src == NULL || dst == NULL)
		return NULL;	

	wstrcpy(dst, src);
	return dst;
#else

	char *dsttmp = dst;

	if(src == NULL || dst == NULL)
		return NULL;
		
	if((unsigned char)*src != 0x80)
	{
		while((unsigned char)*src != 0)
		{
			*dsttmp++ = *src++;
		}

		*dsttmp = 0;
	}	
	else
	{
		*dsttmp++ = *src++;		
		
		while((unsigned short)(((unsigned char)*src<<8)+((unsigned char)*(src+1))) != 0)
		{
			*dsttmp++ = *src++;
			*dsttmp++ = *src++;
		}

		*dsttmp++	= 0;
		*dsttmp		= 0;
	}	
	return dst;	
#endif
	
}

//如为unicode，则num为除unicode头\x80外的字节个数
MMS_S8 	  *MMS_strncpy (MMS_S8 *dst, const MMS_S8 *src, MMS_U32 num)
{
#if (MMS_TIMECRITICAL == 0)
	unsigned int tmplen = num;
	int lenth = wstrlen((char *)src);

	if(src == NULL || dst == NULL)
		return NULL;

	if((unsigned char)*src == 0x80)
		tmplen += 1;
		
	if(lenth > tmplen)
		lenth = tmplen;
		
	memcpy(dst, src, lenth);
	dst[lenth] = 0;
	
	if((unsigned char)*src == 0x80)
		dst[lenth+1] = 0;

	return dst;
#else
	char *dsttmp = dst;
	
	if(src == NULL || dst == NULL)
		return NULL;

	if((unsigned char)*src != 0x80)	//ASCII
	{
		while(*src != 0 && num)
		{
			*dsttmp++ = *src++;
			num--;
		}
		*dsttmp = 0;
	}
	else //Unicode
	{
		*dsttmp++ = *src++;
		while((unsigned short)(((unsigned char)*src<<8)+((unsigned char)*(src+1))) != 0 && num)
		{
			*dsttmp++ = *src++;
			*dsttmp++ = *src++;
			num -= 2;
		}

		*dsttmp++	= 0;
		*dsttmp		= 0;
	}

	return dst;
#endif
}

MMS_S32 MMS_strcmp (MMS_S8 *str1,  const MMS_S8* str2)
{
#if (MMS_TIMECRITICAL == 0)
	MMS_S32 ret;
	char *ss1 = str1;
	const char *ss2 = str2;
	if((unsigned char)*ss1 == 0x80 && (unsigned char)*ss2 == 0x80)
	{
		ret = wstrcmp((unsigned short*)(ss1+1),(unsigned short *)(ss2+1));
		if(ret > 0 )
			return 1;
		else if (ret == 0)
			return 0;
		else 
			return -1;
	}
	else if((U8)*ss1 != 0x80 && (U8)*ss2 != 0x80)
	{
		ret = strcmp(ss1, ss2);
    	return ret;
	}
	else
		return -2;
#else
	char *ss1 = str1;
	const char *ss2 = str2;
	short diff;
	unsigned short uch;
	
	if((unsigned char)*ss1 != 0x80 && (unsigned char)*ss2 != 0x80)
	{		
		while((diff = (*ss1 - *ss2)) == 0 && (unsigned char)*ss1)
		{
			ss1++;
			ss2++;
		}
	}
	else if((unsigned char)*ss1 == 0x80 && (unsigned char)*ss2 == 0x80)
	{
		ss1++;
		ss2++;
		uch = ((unsigned char)*ss1<<8) + (unsigned char)*(ss1+1);
		while((diff = (uch - (((unsigned char)*ss2<<8) + (unsigned char)*(ss2+1)))) == 0 && uch)
		{
			ss1 += 2;
			ss2 += 2;
			uch = ((unsigned char)*ss1<<8) + (unsigned char)*(ss1+1);	
		}
	}
	else
		return -2;

	if(diff > 0)
		return 1;
	else if(diff < 0)
		return -1;

	return 0;	
#endif
}

MMS_S8 *MMS_strcat (MMS_S8 *str,  const MMS_S8 *append)
{
#if (MMS_TIMECRITICAL == 0)
	char *tmpstr;
	unsigned char *ss1=(unsigned char*)str;
	unsigned char *ss2=(unsigned char*)append;
	int len1 = wstrlen((char*)ss1);
	int len2 = wstrlen((char*)ss2);
	
	if ((MMS_U8)*ss1 != 0x80 && (MMS_U8)*ss2 != 0x80)
	{
		memcpy(&str[len1],ss2,len2);
		str[len1+len2]=0x00;
	} 
	else if ((MMS_U8)*ss1 == 0x80 && (MMS_U8)*ss2 == 0x80)
	{
		memcpy(&str[len1],&ss2[1],len2-1);
		str[len1+len2-1]=0;
		str[len1+len2]=0;
	} 
	else if ((MMS_U8)*ss1 == 0x80 && (MMS_U8)*ss2 != 0x80)
	{
		int sizeAlloc;
		MMS_new(tmpstr, sizeAlloc = 2*len2+3);
		AscEx_To_Unicode((char *)ss2, tmpstr);
		memcpy(&str[len1],&tmpstr[1],2*len2);
		str[len1+2*len2]=0;
		str[len1+2*len2+1]=0;
		
		MMS_free(tmpstr, sizeAlloc);
	}
	else if ((MMS_U8)*ss1 != 0x80 && (MMS_U8)*ss2 == 0x80)
	{
		int sizeAlloc;
		MMS_new( tmpstr, sizeAlloc = 2*len1+3);
		AscEx_To_Unicode((char *)ss1, tmpstr);
		memcpy(str,tmpstr,2*len1+1);
		memcpy(&str[2*len1+1],&ss2[1],len2-1);
		str[2*len1+len2]=0;
		str[2*len1+len2+1]=0;
		
		MMS_free(tmpstr,sizeAlloc);
	}
	return str;
#else
	char *strtmp = str;
	char *aptmp = (char*)append;
	char *tmpstr;
	int len1, len2;
	
	if((unsigned char)*strtmp != 0x80 && (unsigned char)*aptmp != 0x80)
	{
		while(*strtmp != 0)
			strtmp++;
			
		while(*aptmp != 0)		
			*strtmp ++ = *aptmp++;
		
		*strtmp = 0;
	}
	else if((unsigned char)*strtmp == 0x80 && (unsigned char)*aptmp == 0x80)
	{
		strtmp++;
		aptmp++;
		while((((unsigned char)*strtmp<<8) + ((unsigned char)*(strtmp+1))) != 0)
			strtmp += 2;

		while((((unsigned char)*aptmp<<8) + ((unsigned char)*(aptmp+1))) != 0)	
		{
			*aptmp++ = *strtmp++;
			*aptmp++ = *strtmp++;
		}

		*strtmp++	= 0;
		*strtmp		= 0;
	}
	else if ((MMS_U8)*strtmp == 0x80 && (MMS_U8)*aptmp != 0x80)
	{
		int sizeAlloc;

		len1 = wstrlen((char*)str);
		len2 = wstrlen((char*)append);
	
		MMS_new(tmpstr, sizeAlloc = 2*len2+3);
		AscEx_To_Unicode((char *)aptmp, tmpstr);
		memcpy(&str[len1],&tmpstr[1],2*len2);
		str[len1+2*len2]=0;
		str[len1+2*len2+1]=0;
		
		MMS_free(tmpstr, sizeAlloc);
	}
	else if ((MMS_U8)*strtmp != 0x80 && (MMS_U8)*aptmp == 0x80)
	{
		int sizeAlloc;

		len1 = wstrlen((char*)str);
		len2 = wstrlen((char*)append);
		MMS_new( tmpstr, sizeAlloc = 2*len1+3);
		AscEx_To_Unicode((char *)strtmp, tmpstr);
		memcpy(str,tmpstr,2*len1+1);
		memcpy(&str[2*len1+1],&aptmp[1],len2-1);
		str[2*len1+len2]=0;
		str[2*len1+len2+1]=0;
		
		MMS_free(tmpstr,sizeAlloc);
	}
	return str;
#endif
}

#if 0
//no
MMS_S32    MMS_strncmp (MMS_S8 *str1,  const MMS_S8 *str2,  MMS_U32 num)
{
	MMS_S32 ret;
	char *ss1 = str1;
	const char *ss2 = str2;
	if((unsigned char)ss1[0] == 0x80 && (unsigned char)ss2[0] == 0x80)
	{
		ret = wstrncmp((unsigned short*)(ss1+1),(unsigned short *)(ss2+1));
		if(ret > 0 )
			return 1;
		else if (ret == 0)
			return 0;
		else 
			return -1;
	}
	else if((unsigned char)ss1[0] != 0x80 && (unsigned char)ss2[0] != 0x80)
	{
		ret = strncmp(ss1, ss2 ,num);
		return ret;
	}
	else
		return -2;
/*
	MMS_S32 ret; 
	ret = wstrncmp(str1, str2, num);
	return ret;*/
}

//no
MMS_S32    MMS_strcasecmp (MMS_S8 *str1, MMS_S8 *str2)
{
    if ((str1 == 0)||(str2 == 0))