mmi_common.c

嵌入式展讯mmi层kernel的c 源代码

                      )
{
    uint32      day = 0;

    //check if the date value range is valid
    if ( (tm_mday > 31) || (tm_mon > 12) 
        ||(tm_year > 2050))
    {
        SCI_TRACE_LOW("MMI_COMMON:tm_mday = %d,tm_mon = %d,tm_year = %d\n",
            tm_mday ,tm_mon ,tm_year);
        return 0;
    }
    
    if(TM_IsLeapYear(tm_year))
    {
        day = dayfrom2000year[tm_year-YEAR_START]
            +dayfromjan1run[tm_mon-MONTH_START]
            +tm_mday - 1;
    }
    else
    {
        day = dayfrom2000year[tm_year-YEAR_START]
            +dayfromjan1[tm_mon-MONTH_START]
            +tm_mday - 1;
    }
    
    return (uint32)(((day*24 + tm_hour)*60 +tm_min) *60 + tm_sec);
}

/*****************************************************************************/
// 	Description : count the lapsed year from 2000
//	Global resource dependence : none
//  Author:
//	Note:
/*****************************************************************************/
uint32 MMI_DayToYear(uint32 *day_in)
{
    uint32 day;
    uint16 year_400,year_100,year_4,leap_year,year;
    
    day = *day_in;
    year = day/ 365;
    day = day % 365;
    
    year_400 = year/400;
    year_100 = year/100;
    year_4 = year/4;
    
    //Get the number of the leap year,2000 year is leap year
    leap_year = year_4 - year_100 + year_400 + 1;
    if(MMI_IsLeapYear(year))
    {
        leap_year--;
    }
    
    if(day > leap_year)
    {
        //The number of year don't change
        day = day - leap_year;
    }
    else
    {
        //The number of year change
        year -- ;
        if(leap_year < 365)
        {
            if(MMI_IsLeapYear(year))
            {
                day = 366 + day - leap_year;
            }
            else
            {
                day = 365 + day - leap_year;
            }
        }
        else
        {
            SCI_TRACE_MID("MMI_COMMON:error leap_year = %d\n",leap_year);
            //@steven , 6.25 ,handle assert
			//SCI_PASSERT(0,("leap_year = %d", leap_year));
			return 2000;   //return a year value
        }
    }
    
    
    *day_in = day;
    
    return 2000+year;
}

/*****************************************************************************/
// 	Description : count the date
//	Global resource dependence : none
//  Author:
//	Note:
/*****************************************************************************/
uint32 MMI_DayToMonth( //return month
                       BOOLEAN leap_year,
                       uint32 *day
                       )
{
    uint8 month = 0;
    
    //@steven  ,  6.25 ,handle assert
	//SCI_ASSERT(*day <= 365 + leap_year);
	if(*day > 365 + leap_year)
	{
		SCI_TRACE_MID("MMI_COMMON:error day = %d\n",*day);
		return  1; // return month = 1
	}
    
    if(leap_year)
    {
        for(month = 0 ; month < 13; month++)
        {
            if(*day <= dayofleapyear[month])
            {
                *day -= dayofleapyear[month-1];
                break;
            }
        }
    }
    else
    {
        for(month = 0 ; month < 13; month++)
        {
            if(*day <= dayfromjan1[month])
            {
                *day -= dayfromjan1[month-1];
                break;
            }
        }
        
    }
    //@steven , 6.25 ,handle assert
	//SCI_PASSERT(month > 0,("month = %d",month));
	if(month <= 0)
	{
		SCI_TRACE_MID("MMI_COMMON:error month = %d\n",month);
		return 1;    //return month = 1 
	}
    
    return month;
}

/*****************************************************************************/
// 	Description : turn second into tm struct
//	Global resource dependence : none
//  Author:
//	Note:
/*****************************************************************************/
MMI_TM_T MMI_Second2Tm(uint32 second)
{
    MMI_TM_T tm;
    uint32 day;
    uint32 rem;
    
    tm.tm_sec = second % 60;
    rem = second / 60;
    tm.tm_min = rem % 60;
    rem /= 60;
    tm.tm_hour = rem %24;
    day  = rem / 24;
    day ++;
    if(day < 30)
    {
        tm.tm_year = 2000;
        tm.tm_mon = 1;
        tm.tm_mday = day;
    }
    else
    {
        tm.tm_year = MMI_DayToYear(&day);
        tm.tm_mon = MMI_DayToMonth(MMI_IsLeapYear(tm.tm_year),&day);
        tm.tm_mday = day;
    }
    return tm;
    
}

/*****************************************************************************/
// 	Description : This function is to changing from ASCII alphabet table to 03.38 alphabet table
//	Global resource dependence : none
//  Author: sunsome.ju
//	Note: 
//  Return: 
/*****************************************************************************/

unsigned char MMI_Ascii2default(
    uint8             *ascii_ptr,
    uint8             *default_ptr,
    uint16            str_len)
{
    unsigned char return_val = 0;
    uint16 i = 0;


    for(i=0;i<str_len;i++)
    {
        if(*ascii_ptr >=0x80)
        {
            return_val = 0;
            return return_val;
        }
        else
        {
            *default_ptr++ = ascii_to_default_table[*ascii_ptr++];
        }
    }

    return_val = 1;
    return return_val;

}

/*****************************************************************************/
// 	Description : This function is to changing from 03.38 alphabet table to ASCII alphabet table
//	Global resource dependence : none
//  Author: sunsome.ju
//	Note: 
//  Return: 
/*****************************************************************************/

unsigned char MMI_Default2Ascii(
    uint8           *default_ptr,
    uint8           *ascii_ptr,
    uint16          str_len)
{
    unsigned char return_val = 0;
    uint16 i = 0;
	uint16 j = 0;


    for(i=0;i<str_len;i++)
    {
        if(*default_ptr >=0x80)
        {
            return_val = 0;
            return return_val;
        }
        else
        {
		     if(*default_ptr == 0x1b )
		     {
				 if(*default_ptr++>=0x80)
				 {
					 return_val = 0;
					 return return_val;
				 }
				 else
				 {
					 *ascii_ptr++ = default_to_ascii_extension_table[*default_ptr++];
				 }
				i++;
		     }
		     else
		    {
				 *ascii_ptr++ = default_to_ascii_table[*default_ptr++];
		     }
        }
    }

    return_val = 1;
    return return_val;

}

/*****************************************************************************/
// 	Description :to changing number string to ucsw
//	Global resource dependence : none
//  Author: louis.wei
//	Note: 
//  Return: 
/*****************************************************************************/
void   MMI_NumStrToUCS2(
                         uint8  *num_str,
                         uint16  num_len,
                         uint8  *ucs2_str
                         )
{
    uint16   i = 0;

    SCI_ASSERT( PNULL != num_str );
    SCI_ASSERT( PNULL != ucs2_str );
    
    for( i = 0; i < num_len; i++ )
    {
        ucs2_str[2*i] = 0x00;
        ucs2_str[2*i+1] = num_str[i];
    }

}

#define	MMI_BUFF_LEN 		5
/*****************************************************************************/
// 	Description :to changing integate to string
//	Global resource dependence : none
//  Author: louis.wei
//	Note: 
//  Return: 
/*****************************************************************************/
void MMI_IntToStr(
				uint16	value,
				uint8	*buf_ptr
				)
{
	uint8	i = 0;
	uint8	buff[ MMI_BUFF_LEN ] = {0};
	uint16	value_tmp = value;
	uint16	temp = 0;
	uint8	remainder =0;
	
	SCI_ASSERT( PNULL != buf_ptr );

	for( i = 0; ( i < MMI_BUFF_LEN ) && ( value_tmp > 0 ); i ++ )
		{
			temp = value_tmp / 10;
			remainder = value_tmp - temp*10;
			value_tmp = temp;

			buff[MMI_BUFF_LEN - 1 - i ] = remainder + '0';
		}

    // 这是一个老函数， 无法得知buf_ptr的长度，并且这个函数目前没有被调用
	SCI_MEMCPY( buf_ptr , (buff + MMI_BUFF_LEN - i ), i );
	
}

/*****************************************************************************/
// 	Description :change enum type and plan of number to uint8 npi_ton,请参考PB
//	Global resource dependence : none
//  Author: jassmine.meng
//	Note: 
//  Return: 
/*****************************************************************************/
uint8 MMI_ChangeTypePlanToUint8(
                                MN_NUMBER_TYPE_E    number_type,
                                MN_NUMBER_PLAN_E    number_plan
                                )
{
    uint8   npi_ton = 0,num_type = 0,num_plan = 0;

    num_type = (uint8)((number_type & 0x000F));
    num_plan = (uint8)((number_plan & 0x000F));

    npi_ton = (num_type << 4) + num_plan;

    return (npi_ton);
}