filesystemsrc.c

MTK手机平台的MMI部分的源代码

{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S32 nRead = 0;
    S32 nDataAvailable;
    S32 nBytesCopied = 0;
    S32 nReqdBytes = nBufferSize;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    *pnRead = 0;    /* Max : can be removed later */
    while (nBytesCopied < nBufferSize)
    {
        nDataAvailable = gnFileBytesRead - gnCurrBuffIndex;
        if (nDataAvailable >= nReqdBytes)
        {
            memcpy(
                (void*)(((S8*) pBuffer) + nBytesCopied),
                (void*)(((S8*) gFileBuffer) + gnCurrBuffIndex),
                nReqdBytes);
            gnCurrBuffIndex += nReqdBytes;
            *pnRead += nReqdBytes;  /**pnRead = nReqdBytes; *//* Max : can be removed later */
        #ifndef MMI_ON_WIN32
            return FS_NO_ERROR;
        #else 
            return nReqdBytes;
        #endif 
        }
        else
        {
            memcpy((((S8*) pBuffer) + nBytesCopied), (void*)(((S8*) gFileBuffer) + gnCurrBuffIndex), nDataAvailable);
            nBytesCopied += nDataAvailable;
            /* nRead = pfread(gFileBuffer,1,MAX_BUFF_SIZE,handle,&gnFileBytesRead); */
            gCurrentFileOffset += gnFileBytesRead;

            (*pnRead) += nDataAvailable;    /* nBytesCopied; *//* Max : can be removed later */
            gnCurrBuffIndex = 0;
            nReqdBytes -= nDataAvailable;   /* nBytesCopied; */

            if (pfError(nRead) || gnFileBytesRead == 0)
            {
                gbIsCurrentFileEnd = TRUE;
            #ifndef MMI_ON_WIN32
                return FS_NO_ERROR;
            #else 
                return nReqdBytes;
            #endif 
            }
        }
    }

#ifndef MMI_ON_WIN32
    return FS_NO_ERROR;
#else 
    return nReqdBytes;
#endif 
}


/*****************************************************************************
 * FUNCTION
 *  IsEndOfCurrentFile
 * DESCRIPTION
 *  
 * PARAMETERS
 *  void
 * RETURNS
 *  
 *****************************************************************************/
pBOOL IsEndOfCurrentFile()
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (gnCurrBuffIndex - gnFileBytesRead >= 0)
        if (gbIsCurrentFileEnd)
        {
            return TRUE;
        }
    return FALSE;
}


/*****************************************************************************
 * FUNCTION
 *  pCopyFile
 * DESCRIPTION
 *  
 * PARAMETERS
 *  pSourceFile         [IN]        
 *  pDestFile           [IN]        
 *  bFailIfExists       [IN]        
 * RETURNS
 *  
 *****************************************************************************/
S32 pCopyFile(PU8 pSourceFile, PU8 pDestFile, pBOOL bFailIfExists)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S32 result = FS_NO_ERROR;
    U8 UI_temp_buffer[512];
    FILE_HANDLE fsourcefile;
    FILE_HANDLE fdestfile;
    S32 nRead;
    S32 nBytesRead = 0;
    S32 nSize = sizeof(UI_temp_buffer);

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    fsourcefile = pfopen(pSourceFile, PFS_READ_BINARY);
    if (fsourcefile > 0)
    {
        if (bFailIfExists)
        {
            fdestfile = pfopen(pDestFile, PFS_READ);
            if (fdestfile)
            {   /* Destination file already exists. Exit */
                pfclose(fsourcefile);
                pfclose(fdestfile);
                return FS_FILE_EXISTS;
            }
            pfclose(fdestfile);
        }

        fdestfile = pfopen(pDestFile, PFS_WRITE);

        if (fdestfile > 0)
        {
            do
            {
                nRead = pfread(UI_temp_buffer, 1, nSize, fsourcefile, &nBytesRead);
                result = pfwrite(UI_temp_buffer, 1, nBytesRead, fdestfile, &nRead);
            } while (nBytesRead >= nSize && result == FS_NO_ERROR);
            pfclose(fdestfile);
        }
        else
        {
            result = (S32) fdestfile;
        }
        pfclose(fsourcefile);
        return result;
    }
    else
    {
        return (S32) fsourcefile;
    }
}

#ifdef __MMI_DOWNLOADABLE_THEMES_SUPPORT__


/*****************************************************************************
 * FUNCTION
 *  pCopyFileFromOffset
 * DESCRIPTION
 *  
 * PARAMETERS
 *  fSourceFile     [IN]        
 *  pDestFile       [IN]        
 *  offset          [IN]        
 *  size            [IN]        
 * RETURNS
 *  
 *****************************************************************************/
S32 pCopyFileFromOffset(FILE_HANDLE fSourceFile, PU8 pDestFile, U32 offset, U32 size)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    S32 result = FS_NO_ERROR;
    U32 fp;
    U8 temp_buffer[512];
    FILE_HANDLE fDestFile;
    U32 nBytesWritten = 0;
    U32 nBytesRead = 0;
    U32 nSize = sizeof(temp_buffer);
    U16 iter = (size / 512);
    U16 lastIter = (size % 512);
    U16 i = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    FS_GetFilePosition(fSourceFile, &fp);
    fDestFile = FS_Open((U16*) pDestFile, FS_CREATE | FS_READ_WRITE);
    if (fDestFile > 0)
    {
        DRM_seek_file(fSourceFile, offset, FS_FILE_BEGIN);
        do
        {
            DRM_read_file(fSourceFile, temp_buffer, nSize, &nBytesRead);
            result = FS_Write(fDestFile, temp_buffer, nBytesRead, &nBytesWritten);
            ++i;
            /* } while(nBytesRead>=nSize && result == FS_NO_ERROR); */
        } while (i < iter && result == FS_NO_ERROR);

        DRM_read_file(fSourceFile, temp_buffer, lastIter, &nBytesRead);
        result = FS_Write(fDestFile, temp_buffer, nBytesRead, &nBytesWritten);

        FS_Close(fDestFile);
        /* if there is an error in writing or reading the audio file then tem file must be deleted */
        if (result != FS_NO_ERROR)
        {
            FS_Delete((U16*) pDestFile);
        }
    }
    else
    {
        result = (S32) fDestFile;
    }
    DRM_seek_file(fSourceFile, fp, FS_FILE_BEGIN);
    return result;
}
#endif /* __MMI_DOWNLOADABLE_THEMES_SUPPORT__ */ 

#ifdef MMI_ON_WIN32


/*****************************************************************************
 * FUNCTION
 *  OpenFileFS
 * DESCRIPTION
 *  
 * PARAMETERS
 *  pFileName       [?]     
 *  pType           [?]     
 * RETURNS
 *  
 *****************************************************************************/
FILE_HANDLE OpenFileFS(U8 *pFileName, U8 *pType)
{
#ifdef __UCS2_ENCODING
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    U8 *filename;
#else /* __UCS2_ENCODING */ 
    U8 filename[MAX_FILE_NAME];
#endif /* __UCS2_ENCODING */ 
    FILE_HANDLE f = -1;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
#ifdef __UCS2_ENCODING

    filename = pFileName;

#else /* __UCS2_ENCODING */ 

    AnsiiToUnicodeString(filename, pFileName);

#endif /* __UCS2_ENCODING */ 

    if (strstr(pType, "r+"))
    {

        f = FS_Open((WCHAR*) filename, FS_READ_WRITE);
    }
    else if (strstr(pType, "r"))
    {

        f = FS_Open((WCHAR*) filename, FS_READ_ONLY);
    }
    else if (strstr(pType, "w"))
    {

        /* "w" and "w+" have the same effect */

        f = FS_Open((WCHAR*) filename, FS_READ_WRITE | FS_CREATE_ALWAYS);
    }
    else if (strstr(pType, "a"))
    {

        /* "a" and "a+" have the same effect */

        f = FS_Open((WCHAR*) filename, FS_READ_WRITE | FS_CREATE_ALWAYS);

        if (f > FS_NO_ERROR)
        {

            FS_Seek(f, 0, FS_FILE_END);
        }
    }

    /*
     * NoteXXX: Originally FILE_HANDLE is defined as (FILE *)
     *          and OpenFSFile() will use fopen to open a file.
     *          If fail, the return value is NULL.
     *          But zero value means success for our FS_HANDLE. 
     *          For backward compatibility, we need to do a little
     *          conversion.
     *          
     */

    if (f < FS_NO_ERROR)

    {
        return 0;
    }

    else

    {
        return f;
    }
}


/*****************************************************************************
 * FUNCTION
 *  fdelete
 * DESCRIPTION
 *  
 * PARAMETERS
 *  fFile       [?]     
 * RETURNS
 *  
 *****************************************************************************/
S32 fdelete(U8 *fFile)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int retval;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    retval = FS_Delete((WCHAR*) fFile);

    if (retval == FS_NO_ERROR)

        /* succeed */

    {
        return 0;
    }
    else
        /* fail */

    {
        return 1;
    }
}


/*****************************************************************************
 * FUNCTION
 *  frename
 * DESCRIPTION
 *  
 * PARAMETERS
 *  sFile       [?]     
 *  dFile       [?]     
 * RETURNS
 *  
 *****************************************************************************/
S32 frename(U8 *sFile, U8 *dFile)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int retval;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    retval = FS_Rename((WCHAR*) sFile, (WCHAR*) dFile);