plxmms_util.c

mtk wap和mms代码。。适应mtk 25。26平台

\**************************************************************************/
char* MMS_Strncat(char *s1, const char *s2, unsigned int n)
{
#ifdef MMI_ON_WIN32
    return strncat(s1, s2, n);
#else
    return plx_strncat(s1, s2, n);
#endif
}

/***************************************************************************
* Function	MMS_Strcmp
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
int MMS_Strcmp(const char *s1, const char *s2)
{
#ifdef MMI_ON_WIN32
    return strcmp(s1, s2);
#else
    return plx_strcmp(s1, s2);
#endif
}

/***************************************************************************
* Function	MMS_Stristr
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
char* MMS_Stristr(const char *s1, const char *s2)
{
    char* ps1    = NULL;
    char* ps2    = NULL;
    char* result = NULL;

#ifdef MMS_DEBUG
    PlxTrace("MMS_Stristr, s1=%s, s2=%s\r\n", s1, s2);
#endif

    if(!s1 || !s2)
        return NULL;

    ps1 = (char*)MMS_Malloc(MMS_Strlen(s1)+1);
    ps2 = (char*)MMS_Malloc(MMS_Strlen(s2)+1);

    if(!ps1 || !ps2)
    {
        if(ps1)
            MMS_Free((void*)ps1);
        if(ps2)
            MMS_Free((void*)ps2);
        return NULL;
    }

    MMS_Strcpy(ps1, s1);
    MMS_Strcpy(ps2, s2);

    plx_strlwr(ps1);
    plx_strlwr(ps2);

#ifdef MMS_DEBUG
    PlxTrace("ps1=%s, ps2=%s\r\n", ps1, ps2);
#endif

    result = MMS_Strstr(ps1, ps2);
/*
    if(!result)
    {
#ifdef MMS_DEBUG
    PlxTrace("!result\r\n");
#endif
        if(MMS_Strcmp(ps1, ps2) == 0)
        {
#ifdef MMS_DEBUG
    PlxTrace("MMS_Strcmp(ps1, ps2) == 0\r\n");
#endif
            MMS_Free((void*)ps1);
            MMS_Free((void*)ps2);
            return (char*)1;
        }
#ifdef MMS_DEBUG
    PlxTrace("return NULL\r\n");
#endif
        MMS_Free((void*)ps1);
        MMS_Free((void*)ps2);
        return NULL;
    }
*/
    MMS_Free((void*)ps1);
    MMS_Free((void*)ps2);

    return result;
}

/***************************************************************************
* Function	MMS_FindCharFromEnd
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
char* MMS_FindCharFromEnd(const char* str, char c)
{
    int len;
    char* p;

    if(!str)
        return NULL;
    if(*str == 0)
        return NULL;

    len = MMS_Strlen(str);
    p = (char*)(str + len - 1);
    while(p != str)
    {
        if(*p == c)
            return p;
        p--;
    }

    if(*p == c)
        return p;
    
    return NULL;
}

/***************************************************************************
* Function	MMS_GetUTF8CharCount
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
int MMS_GetUTF8CharCount(unsigned short wCode)
{
    if (wCode < 0x80)
        return 1;
    else if (wCode < 0x800)
        return 2;
    else
        return 3;
}

/***************************************************************************
* Function	MMS_Unicode2UTF8
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
void MMS_Unicode2UTF8(unsigned short wCode, unsigned char **lppUtf8)
{
    if (wCode < 0x80)
        *(*lppUtf8)++ = (unsigned char)wCode;
    else if (wCode < 0x800)
    {
        *(*lppUtf8)++ = (unsigned char)((wCode >> 6) | 0xC0);
        *(*lppUtf8)++ = (unsigned char)((wCode & 0x3F) | 0x80);
    }
    else
    {
        *(*lppUtf8)++ = (unsigned char)((wCode >> 12) | 0xE0);
        *(*lppUtf8)++ = (unsigned char)(((wCode >> 6) & 0x3F) | 0x80);
        *(*lppUtf8)++ = (unsigned char)((wCode & 0x3F) | 0x80);
    }
}

/***************************************************************************
* Function	PlxMmsWideCharToUTF8Len
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
int PlxMmsWideCharToUTF8Len(const char * lpWideCharStr, int cWideCharLen)
{
	unsigned short *pwSrc = (unsigned short*)lpWideCharStr;
	int len = 0;
	
	while (cWideCharLen > 0)
    {
        int count = MMS_GetUTF8CharCount(*pwSrc);
		
		pwSrc++;
		cWideCharLen--;
		
		len += count;
	}
	return len;
}

/***************************************************************************
* Function	MMS_WFindCharFromEnd
* Purpose	
* Params	
* Return	
* Remarks	
\**************************************************************************/
U8* MMS_WFindCharFromEnd(const U8* pSrc, int len, const char find)//const unsigned short wchar)
{
    int i;
//    unsigned short* p;

#ifdef MMS_DEBUG
    char cName[MAX_OBJ_NAME_LEN];
//    UnicodeToAnsii((S8*)cName, (S8*)pSrc);
    PlxTrace("MMS_WFindCharFromEnd\r\n");
    PlxTrace("name=%s", cName);
    PlxTrace("wchar=%x", find);
#endif

    if(!pSrc || len == 0)
        return NULL;

    i = len*2;
    while(i >= 0)
    {
#ifdef MMS_DEBUG
        PlxTrace("in while, *p=%x, *(p+1)=%x\r\n", pSrc[i], pSrc[i+1]);
#endif
        if(pSrc[i+1] == 0 &&
           pSrc[i] == find)
            return (U8*)(pSrc+i);

        i -= 2;
    }

    return NULL;
}

unsigned long GetFreeFsSize(void)
{
    FS_DiskInfo DiskInfo;
    unsigned int freesize;
    S8  FS_Path[PLXMMS_PATH_MAXLEN*2];
    S32				fs_ret;

#ifdef MMS_DEBUG
    PlxTrace("GetFreeFsSize\r\n");
#endif

#ifdef MMS_SELECTSTOREPATH
    AnsiiToUnicodeString(FS_Path, (S8*)g_cur_path);
#elif defined(MMS_SAVEONCARD)
    AnsiiToUnicodeString(FS_Path, (S8*)g_plug_path);
#else
    AnsiiToUnicodeString(FS_Path, (S8*)g_mms_path);
#endif

    if(FS_Path[0] >= 0x5B)
        FS_Path[0] -= 32;
#ifdef MMS_DEBUG
    PlxTrace("FS_Path[0] = %c\r\n", (UINT)FS_Path[0]);
#endif

    FS_Path[2] = ':';
    FS_Path[4] = 0;
    FS_Path[5] = 0;
#ifdef MMS_DEBUG
    PlxTrace("FS_Path = %02x%02x%02x%02x%02x%02x\r\n", (char)FS_Path[0], (char)FS_Path[1],
        (char)FS_Path[2], (char)FS_Path[3], (char)FS_Path[4], (char)FS_Path[5]);
#endif
    fs_ret = FS_GetDiskInfo((PU16)FS_Path,  &DiskInfo, FS_DI_BASIC_INFO|FS_DI_FREE_SPACE);
    if(fs_ret < 0)
        return 0;

#ifdef MMS_DEBUG
    PlxTrace("FreeClusters = %d\r\n", DiskInfo.FreeClusters);
#endif

    freesize = DiskInfo.FreeClusters*DiskInfo.SectorsPerCluster*DiskInfo.BytesPerSector;
    if (freesize < PLX_MMS_SAVE_SPACE)
		return 0;
	else
		return (freesize-PLX_MMS_SAVE_SPACE);
}

BOOL IsLowSpace(long size)
{
#ifdef MMS_DEBUG
    PlxTrace("IsLowSpace, size = %ld\r\n", size);
    //return FALSE;
#endif
	if(size > 0)
		return (GetFreeFsSize() < (unsigned long)size*2);
	else
		return (GetFreeFsSize() <= (unsigned long)PLX_MMS_LOWSPACE_EDIT);
}

/***************************************************************************
* Function	MMS_UTF8ToUnicode
* Purpose	
* Params	utfStr : UTF8 string
*           utfLen : UTF8 string length, in byte
*           wLen   : Unicode string length, in wchar
* Return	
* Remarks	
\**************************************************************************/
WCHAR* MMS_UTF8ToUnicode(unsigned char* utfStr, int utfLen, int* wLen)
{
    WCHAR* wStr = NULL;
    int    wStrLen;

    if(!utfStr || !wLen)
        return NULL;

    *wLen = 0;
    wStrLen = (utfLen+1) * 2;
    wStr = (WCHAR*)MMS_Malloc(wStrLen);

    if(!wStr)
        return NULL;
    MMS_Memset((void*)wStr, 0, wStrLen);

    *wLen = PlxMmsUTF8ToWideChar((const char*)utfStr, utfLen, 
                (char*)wStr, wStrLen);
    *wLen = *wLen / 2;
    wStr[*wLen] = 0x0000;

    return wStr;
}

/***************************************************************************
* Function	MMS_UnicodeToUTF8
* Purpose	
* Params	wStr   : Unicode string
*           wLen   : Unicode string length, in wchar
*           utfLen : UTF8 string length, in byte
* Return	
* Remarks	
\**************************************************************************/
unsigned char* MMS_UnicodeToUTF8(WCHAR* wStr, int wLen, int* utfLen)
{
    unsigned char* utfStr = NULL;
    int            utfStrLen;

    if(!wStr || !utfLen)
        return NULL;

    *utfLen = 0;
    utfStrLen = wLen * 3 + 1;

    utfStr = (unsigned char*)MMS_Malloc(utfStrLen);
    if(!utfStr)
        return NULL;
    MMS_Memset((void*)utfStr, 0, utfStrLen);

    *utfLen = PlxWideCharToUTF8((const char*)wStr, wLen, (char*)utfStr, utfStrLen);

    return utfStr;
}

void GetShowSize(long size, int* size_k, int* size_dec)
{
    long temp;

    temp = (size * 10 + 1023) / 1024;

    *size_k = temp / 10;
    *size_dec = temp % 10;
}