开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
FileSystemSrc.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：33k
源码类别：

MTK

开发平台：

C/C++

FileSystemSrc.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  *  FileSystemSrc.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  
  48.  *
  49.  * Author:
  50.  * -------
  51.  *  
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  *------------------------------------------------------------------------------
  81.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  82.  *==============================================================================
  83.  *******************************************************************************/
  85. /**
  86.  * Copyright Notice
  87.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  88.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  89.  *  (It is illegal to remove this copyright notice from this software or any
  90.  *  portion of it)
  91.  */
  93. /**************************************************************
  95.    FILENAME : FileSystemSrc.h
  97.    PURPOSE     : Source File for the File System 
  99.    REMARKS     : nil
  101.    AUTHOR      : Yogesh
  103.    DATE     : August-01-2003
  105. **************************************************************/
  107. #include "FileSystemDef.h"
  108. #include "Ucs2prot.h"
  109. #include "MMI_features.h"
  110. #include "fs_type.h"
  111. #include "fs_func.h"
  112. #include "fs_errcode.h"
  113. #include "drm_gprot.h"
  116. S32 gnCurrBuffIndex = 0;
  117. S32 gnFileBytesRead = 0;
  118. U8 gFileBuffer[MAX_BUFF_SIZE];
  119. U8 gbIsCurrentFileEnd = FALSE;
  120. S32 gCurrentFileOffset = 0;
  122. /* Leo add for DLT */
  125. /*****************************************************************************
  126.  * FUNCTION
  127.  *  Searchfile
  128.  * DESCRIPTION
  129.  *  
  130.  * PARAMETERS
  131.  *  file_handle     [IN]        
  132.  * RETURNS
  133.  *  
  134.  *****************************************************************************/
  135. S32 Searchfile(FILE_HANDLE file_handle)
  136. {
  137. #ifndef MMI_ON_WIN32
  138.     /*----------------------------------------------------------------*/
  139.     /* Local Variables                                                */
  140.     /*----------------------------------------------------------------*/
  142.     /*----------------------------------------------------------------*/
  143.     /* Code Body                                                      */
  144.     /*----------------------------------------------------------------*/
  145.     return (S32) FS_ParseFH(file_handle);
  146. #else /* MMI_ON_WIN32 */ 
  147.     return 1;
  148. #endif /* MMI_ON_WIN32 */ 
  149. }
  151. /* Leo end */
  154. /*****************************************************************************
  155.  * FUNCTION
  156.  *  pfOpenError
  157.  * DESCRIPTION
  158.  *  
  159.  * PARAMETERS
  160.  *  err     [IN]        
  161.  * RETURNS
  162.  *  
  163.  *****************************************************************************/
  164. S32 pfOpenError(FILE_HANDLE err)
  165. {
  166. #ifndef MMI_ON_WIN32
  167.     /*----------------------------------------------------------------*/
  168.     /* Local Variables                                                */
  169.     /*----------------------------------------------------------------*/
  171.     /*----------------------------------------------------------------*/
  172.     /* Code Body                                                      */
  173.     /*----------------------------------------------------------------*/
  174.     if (err < FS_NO_ERROR)
  175.     {
  176.         return -1;
  177.     }
  178.     else
  179.     {
  180.         return 0;
  181.     }
  183. #else /* MMI_ON_WIN32 */ 
  185.     if (err < FS_NO_ERROR)
  186.     {
  187.         return -1;
  188.     }
  189.     else
  190.     {
  191.         return 0;
  192.     }
  194. #endif /* MMI_ON_WIN32 */ 
  195. }
  198. /*****************************************************************************
  199.  * FUNCTION
  200.  *  pfError
  201.  * DESCRIPTION
  202.  *  
  203.  * PARAMETERS
  204.  *  err     [IN]        
  205.  * RETURNS
  206.  *  
  207.  *****************************************************************************/
  208. S32 pfError(S32 err)
  209. {
  210. #ifndef MMI_ON_WIN32
  211.     /*----------------------------------------------------------------*/
  212.     /* Local Variables                                                */
  213.     /*----------------------------------------------------------------*/
  215.     /*----------------------------------------------------------------*/
  216.     /* Code Body                                                      */
  217.     /*----------------------------------------------------------------*/
  218.     if (err < FS_NO_ERROR)
  219.     {
  220.         return -1;
  221.     }
  222.     else
  223.     {
  224.         return 0;
  225.     }
  227. #else /* MMI_ON_WIN32 */ 
  229.     if (err < FS_NO_ERROR)
  230.     {
  231.         return -1;
  232.     }
  233.     else
  234.     {
  235.         return 0;
  236.     }
  238. #endif /* MMI_ON_WIN32 */ 
  239. }
  242. /*****************************************************************************
  243.  * FUNCTION
  244.  *  GetFSFileSize
  245.  * DESCRIPTION
  246.  *  
  247.  * PARAMETERS
  248.  *  handle      [IN]        
  249.  * RETURNS
  250.  *  
  251.  *****************************************************************************/
  252. S32 GetFSFileSize(FILE_HANDLE handle)
  253. {
  254.     /*----------------------------------------------------------------*/
  255.     /* Local Variables                                                */
  256.     /*----------------------------------------------------------------*/
  257.     S32 nfile_size;
  259. #ifdef MMI_ON_WIN32
  261.     int retval;
  263.     /*----------------------------------------------------------------*/
  264.     /* Code Body                                                      */
  265.     /*----------------------------------------------------------------*/
  266.     retval = FS_GetFileSize(handle, &nfile_size);
  268.     if (retval == FS_NO_ERROR)
  270.     {
  271.         return nfile_size;
  272.     }
  274.     else
  276.     {
  277.         return 0;
  278.     }
  280. #else /* MMI_ON_WIN32 */
  282.     FS_GetFileSize(handle, (U32*) & nfile_size);
  284.     return nfile_size;
  286. #endif 
  287. }
  290. /*****************************************************************************
  291.  * FUNCTION
  292.  *  StartFileRead
  293.  * DESCRIPTION
  294.  *  
  295.  * PARAMETERS
  296.  *  handle      [IN]        
  297.  *  nIndex      [IN]        
  298.  * RETURNS
  299.  *  
  300.  *****************************************************************************/
  301. S32 StartFileRead(FILE_HANDLE handle, U32 nIndex)
  302. {
  303.     /*----------------------------------------------------------------*/
  304.     /* Local Variables                                                */
  305.     /*----------------------------------------------------------------*/
  306.     S32 nError;
  308.     /*----------------------------------------------------------------*/
  309.     /* Code Body                                                      */
  310.     /*----------------------------------------------------------------*/
  311.     gnCurrBuffIndex = 0;
  313.     nError = pfread(gFileBuffer, 1, MAX_BUFF_SIZE, handle, &gnFileBytesRead);
  314.     gbIsCurrentFileEnd = FALSE;
  315.     gCurrentFileOffset = gnFileBytesRead - 1;
  316.     if (pfError(nError) || gnFileBytesRead < MAX_BUFF_SIZE)
  317.     {
  318.         gbIsCurrentFileEnd = TRUE;
  319.         return EOF;
  320.     }
  322.     return 0;
  323. }
  326. /*****************************************************************************
  327.  * FUNCTION
  328.  *  pfgetc
  329.  * DESCRIPTION
  330.  *  
  331.  * PARAMETERS
  332.  *  handle      [IN]        
  333.  * RETURNS
  334.  *  
  335.  *****************************************************************************/
  336. S32 pfgetc(FILE_HANDLE handle)
  337. {
  338.     /*----------------------------------------------------------------*/
  339.     /* Local Variables                                                */
  340.     /*----------------------------------------------------------------*/
  341.     S32 nRead = 0;
  343.     /*----------------------------------------------------------------*/
  344.     /* Code Body                                                      */
  345.     /*----------------------------------------------------------------*/
  346.     if (gnCurrBuffIndex - gnFileBytesRead >= 0)
  347.     {
  348.         nRead = pfread(gFileBuffer, 1, MAX_BUFF_SIZE, handle, &gnFileBytesRead);
  349.         gCurrentFileOffset += gnFileBytesRead;
  350.         gnCurrBuffIndex = 0;
  351.         /* MTK modified, Max: to prevent endless file reading 1201 */
  352.         if (pfError(nRead) || gnFileBytesRead == 0)
  353.         {
  354.             gbIsCurrentFileEnd = TRUE;
  355.             return EOF;
  356.         }
  357.         /* MTK end */
  358.     }
  360.     return (S32) gFileBuffer[gnCurrBuffIndex++];
  361. }
  364. /*****************************************************************************
  365.  * FUNCTION
  366.  *  pCacheFileRead
  367.  * DESCRIPTION
  368.  *  
  369.  * PARAMETERS
  370.  *  handle          [IN]        
  371.  *  nBufferSize     [IN]        
  372.  *  pnRead          [?]         
  373.  *  pBuffer         [?]         
  374.  * RETURNS
  375.  *  
  376.  *****************************************************************************/
  377. S32 pCacheFileRead(FILE_HANDLE handle, S32 nBufferSize, S32 *pnRead, U8 *pBuffer)
  378. {
  379.     /*----------------------------------------------------------------*/
  380.     /* Local Variables                                                */
  381.     /*----------------------------------------------------------------*/
  382.     S32 nRead = 0;
  383.     S32 nDataAvailable;
  384.     S32 nBytesCopied = 0;
  385.     S32 nReqdBytes = nBufferSize;
  387.     /*----------------------------------------------------------------*/
  388.     /* Code Body                                                      */
  389.     /*----------------------------------------------------------------*/
  390.     *pnRead = 0;    /* Max : can be removed later */
  391.     while (nBytesCopied < nBufferSize)
  392.     {
  393.         nDataAvailable = gnFileBytesRead - gnCurrBuffIndex;
  394.         if (nDataAvailable >= nReqdBytes)
  395.         {
  396.             memcpy(
  397.                 (void*)(((S8*) pBuffer) + nBytesCopied),
  398.                 (void*)(((S8*) gFileBuffer) + gnCurrBuffIndex),
  399.                 nReqdBytes);
  400.             gnCurrBuffIndex += nReqdBytes;
  401.             *pnRead += nReqdBytes;  /**pnRead = nReqdBytes; *//* Max : can be removed later */
  402.         #ifndef MMI_ON_WIN32
  403.             return FS_NO_ERROR;
  404.         #else 
  405.             return nReqdBytes;
  406.         #endif 
  407.         }
  408.         else
  409.         {
  410.             memcpy((((S8*) pBuffer) + nBytesCopied), (void*)(((S8*) gFileBuffer) + gnCurrBuffIndex), nDataAvailable);
  411.             nBytesCopied += nDataAvailable;
  412.             /* nRead = pfread(gFileBuffer,1,MAX_BUFF_SIZE,handle,&gnFileBytesRead); */
  413.             gCurrentFileOffset += gnFileBytesRead;
  415.             (*pnRead) += nDataAvailable;    /* nBytesCopied; *//* Max : can be removed later */
  416.             gnCurrBuffIndex = 0;
  417.             nReqdBytes -= nDataAvailable;   /* nBytesCopied; */
  419.             if (pfError(nRead) || gnFileBytesRead == 0)
  420.             {
  421.                 gbIsCurrentFileEnd = TRUE;
  422.             #ifndef MMI_ON_WIN32
  423.                 return FS_NO_ERROR;
  424.             #else 
  425.                 return nReqdBytes;
  426.             #endif 
  427.             }
  428.         }
  429.     }
  431. #ifndef MMI_ON_WIN32
  432.     return FS_NO_ERROR;
  433. #else 
  434.     return nReqdBytes;
  435. #endif 
  436. }
  439. /*****************************************************************************
  440.  * FUNCTION
  441.  *  IsEndOfCurrentFile
  442.  * DESCRIPTION
  443.  *  
  444.  * PARAMETERS
  445.  *  void
  446.  * RETURNS
  447.  *  
  448.  *****************************************************************************/
  449. pBOOL IsEndOfCurrentFile()
  450. {
  451.     /*----------------------------------------------------------------*/
  452.     /* Local Variables                                                */
  453.     /*----------------------------------------------------------------*/
  455.     /*----------------------------------------------------------------*/
  456.     /* Code Body                                                      */
  457.     /*----------------------------------------------------------------*/
  458.     if (gnCurrBuffIndex - gnFileBytesRead >= 0)
  459.         if (gbIsCurrentFileEnd)
  460.         {
  461.             return TRUE;
  462.         }
  463.     return FALSE;
  464. }
  467. /*****************************************************************************
  468.  * FUNCTION
  469.  *  pCopyFile
  470.  * DESCRIPTION
  471.  *  
  472.  * PARAMETERS
  473.  *  pSourceFile         [IN]        
  474.  *  pDestFile           [IN]        
  475.  *  bFailIfExists       [IN]        
  476.  * RETURNS
  477.  *  
  478.  *****************************************************************************/
  479. S32 pCopyFile(PU8 pSourceFile, PU8 pDestFile, pBOOL bFailIfExists)
  480. {
  481.     /*----------------------------------------------------------------*/
  482.     /* Local Variables                                                */
  483.     /*----------------------------------------------------------------*/
  484.     S32 result = FS_NO_ERROR;
  485.     U8 UI_temp_buffer[512];
  486.     FILE_HANDLE fsourcefile;
  487.     FILE_HANDLE fdestfile;
  488.     S32 nRead;
  489.     S32 nBytesRead = 0;
  490.     S32 nSize = sizeof(UI_temp_buffer);
  492.     /*----------------------------------------------------------------*/
  493.     /* Code Body                                                      */
  494.     /*----------------------------------------------------------------*/
  495.     fsourcefile = pfopen(pSourceFile, PFS_READ_BINARY);
  496.     if (fsourcefile > 0)
  497.     {
  498.         if (bFailIfExists)
  499.         {
  500.             fdestfile = pfopen(pDestFile, PFS_READ);
  501.             if (fdestfile)
  502.             {   /* Destination file already exists. Exit */
  503.                 pfclose(fsourcefile);
  504.                 pfclose(fdestfile);
  505.                 return FS_FILE_EXISTS;
  506.             }
  507.             pfclose(fdestfile);
  508.         }
  510.         fdestfile = pfopen(pDestFile, PFS_WRITE);
  512.         if (fdestfile > 0)
  513.         {
  514.             do
  515.             {
  516.                 nRead = pfread(UI_temp_buffer, 1, nSize, fsourcefile, &nBytesRead);
  517.                 result = pfwrite(UI_temp_buffer, 1, nBytesRead, fdestfile, &nRead);
  518.             } while (nBytesRead >= nSize && result == FS_NO_ERROR);
  519.             pfclose(fdestfile);
  520.         }
  521.         else
  522.         {
  523.             result = (S32) fdestfile;
  524.         }
  525.         pfclose(fsourcefile);
  526.         return result;
  527.     }
  528.     else
  529.     {
  530.         return (S32) fsourcefile;
  531.     }
  532. }
  534. #ifdef __MMI_DOWNLOADABLE_THEMES_SUPPORT__
  537. /*****************************************************************************
  538.  * FUNCTION
  539.  *  pCopyFileFromOffset
  540.  * DESCRIPTION
  541.  *  
  542.  * PARAMETERS
  543.  *  fSourceFile     [IN]        
  544.  *  pDestFile       [IN]        
  545.  *  offset          [IN]        
  546.  *  size            [IN]        
  547.  * RETURNS
  548.  *  
  549.  *****************************************************************************/
  550. S32 pCopyFileFromOffset(FILE_HANDLE fSourceFile, PU8 pDestFile, U32 offset, U32 size)
  551. {
  552.     /*----------------------------------------------------------------*/
  553.     /* Local Variables                                                */
  554.     /*----------------------------------------------------------------*/
  555.     S32 result = FS_NO_ERROR;
  556.     U32 fp;
  557.     U8 temp_buffer[512];
  558.     FILE_HANDLE fDestFile;
  559.     U32 nBytesWritten = 0;
  560.     U32 nBytesRead = 0;
  561.     U32 nSize = sizeof(temp_buffer);
  562.     U16 iter = (size / 512);
  563.     U16 lastIter = (size % 512);
  564.     U16 i = 0;
  566.     /*----------------------------------------------------------------*/
  567.     /* Code Body                                                      */
  568.     /*----------------------------------------------------------------*/
  569.     FS_GetFilePosition(fSourceFile, &fp);
  570.     fDestFile = FS_Open((U16*) pDestFile, FS_CREATE | FS_READ_WRITE);
  571.     if (fDestFile > 0)
  572.     {
  573.         DRM_seek_file(fSourceFile, offset, FS_FILE_BEGIN);
  574.         do
  575.         {
  576.             DRM_read_file(fSourceFile, temp_buffer, nSize, &nBytesRead);
  577.             result = FS_Write(fDestFile, temp_buffer, nBytesRead, &nBytesWritten);
  578.             ++i;
  579.             /* } while(nBytesRead>=nSize && result == FS_NO_ERROR); */
  580.         } while (i < iter && result == FS_NO_ERROR);
  582.         DRM_read_file(fSourceFile, temp_buffer, lastIter, &nBytesRead);
  583.         result = FS_Write(fDestFile, temp_buffer, nBytesRead, &nBytesWritten);
  585.         FS_Close(fDestFile);
  586.         /* if there is an error in writing or reading the audio file then tem file must be deleted */
  587.         if (result != FS_NO_ERROR)
  588.         {
  589.             FS_Delete((U16*) pDestFile);
  590.         }
  591.     }
  592.     else
  593.     {
  594.         result = (S32) fDestFile;
  595.     }
  596.     DRM_seek_file(fSourceFile, fp, FS_FILE_BEGIN);
  597.     return result;
  598. }
  599. #endif /* __MMI_DOWNLOADABLE_THEMES_SUPPORT__ */ 
  601. #ifdef MMI_ON_WIN32
  604. /*****************************************************************************
  605.  * FUNCTION
  606.  *  OpenFileFS
  607.  * DESCRIPTION
  608.  *  
  609.  * PARAMETERS
  610.  *  pFileName       [?]     
  611.  *  pType           [?]     
  612.  * RETURNS
  613.  *  
  614.  *****************************************************************************/
  615. FILE_HANDLE OpenFileFS(U8 *pFileName, U8 *pType)
  616. {
  617. #ifdef __UCS2_ENCODING
  618.     /*----------------------------------------------------------------*/
  619.     /* Local Variables                                                */
  620.     /*----------------------------------------------------------------*/
  621.     U8 *filename;
  622. #else /* __UCS2_ENCODING */ 
  623.     U8 filename[MAX_FILE_NAME];
  624. #endif /* __UCS2_ENCODING */ 
  625.     FILE_HANDLE f = -1;
  627.     /*----------------------------------------------------------------*/
  628.     /* Code Body                                                      */
  629.     /*----------------------------------------------------------------*/
  630. #ifdef __UCS2_ENCODING
  632.     filename = pFileName;
  634. #else /* __UCS2_ENCODING */ 
  636.     AnsiiToUnicodeString(filename, pFileName);
  638. #endif /* __UCS2_ENCODING */ 
  640.     if (strstr(pType, "r+"))
  641.     {
  643.         f = FS_Open((WCHAR*) filename, FS_READ_WRITE);
  644.     }
  645.     else if (strstr(pType, "r"))
  646.     {
  648.         f = FS_Open((WCHAR*) filename, FS_READ_ONLY);
  649.     }
  650.     else if (strstr(pType, "w"))
  651.     {
  653.         /* "w" and "w+" have the same effect */
  655.         f = FS_Open((WCHAR*) filename, FS_READ_WRITE | FS_CREATE_ALWAYS);
  656.     }
  657.     else if (strstr(pType, "a"))
  658.     {
  660.         /* "a" and "a+" have the same effect */
  662.         f = FS_Open((WCHAR*) filename, FS_READ_WRITE | FS_CREATE_ALWAYS);
  664.         if (f > FS_NO_ERROR)
  665.         {
  667.             FS_Seek(f, 0, FS_FILE_END);
  668.         }
  669.     }
  671.     /*
  672.      * NoteXXX: Originally FILE_HANDLE is defined as (FILE *)
  673.      *          and OpenFSFile() will use fopen to open a file.
  674.      *          If fail, the return value is NULL.
  675.      *          But zero value means success for our FS_HANDLE. 
  676.      *          For backward compatibility, we need to do a little
  677.      *          conversion.
  678.      *          
  679.      */
  681.     if (f < FS_NO_ERROR)
  683.     {
  684.         return 0;
  685.     }
  687.     else
  689.     {
  690.         return f;
  691.     }
  692. }
  695. /*****************************************************************************
  696.  * FUNCTION
  697.  *  fdelete
  698.  * DESCRIPTION
  699.  *  
  700.  * PARAMETERS
  701.  *  fFile       [?]     
  702.  * RETURNS
  703.  *  
  704.  *****************************************************************************/
  705. S32 fdelete(U8 *fFile)
  706. {
  707.     /*----------------------------------------------------------------*/
  708.     /* Local Variables                                                */
  709.     /*----------------------------------------------------------------*/
  710.     int retval;
  712.     /*----------------------------------------------------------------*/
  713.     /* Code Body                                                      */
  714.     /*----------------------------------------------------------------*/
  715.     retval = FS_Delete((WCHAR*) fFile);
  717.     if (retval == FS_NO_ERROR)
  719.         /* succeed */
  721.     {
  722.         return 0;
  723.     }
  724.     else
  725.         /* fail */
  727.     {
  728.         return 1;
  729.     }
  730. }
  733. /*****************************************************************************
  734.  * FUNCTION
  735.  *  frename
  736.  * DESCRIPTION
  737.  *  
  738.  * PARAMETERS
  739.  *  sFile       [?]     
  740.  *  dFile       [?]     
  741.  * RETURNS
  742.  *  
  743.  *****************************************************************************/
  744. S32 frename(U8 *sFile, U8 *dFile)
  745. {
  746.     /*----------------------------------------------------------------*/
  747.     /* Local Variables                                                */
  748.     /*----------------------------------------------------------------*/
  749.     int retval;
  751.     /*----------------------------------------------------------------*/
  752.     /* Code Body                                                      */
  753.     /*----------------------------------------------------------------*/
  754.     retval = FS_Rename((WCHAR*) sFile, (WCHAR*) dFile);
  756.     if (retval == FS_NO_ERROR)
  758.         /* succeed */
  760.     {
  761.         return 1;
  762.     }
  764.     else
  765.         /* fail */
  767.     {
  768.         return 0;
  769.     }
  770. }
  773. /*****************************************************************************
  774.  * FUNCTION
  775.  *  pFindFirstEx
  776.  * DESCRIPTION
  777.  *  
  778.  * PARAMETERS
  779.  *  x1      [IN]        
  780.  *  x2      [IN]        
  781.  *  x3      [IN]        
  782.  *  x4      [?]         
  783.  *  x5      [IN]        
  784.  *  x6      [IN]        
  785.  * RETURNS
  786.  *  
  787.  *****************************************************************************/
  788. FILE_HANDLE pFindFirstEx(const PS8 x1, U8 x2, U8 x3, void *x4, PS8 x5, U32 x6)
  789. {
  790.     /*----------------------------------------------------------------*/
  791.     /* Local Variables                                                */
  792.     /*----------------------------------------------------------------*/
  794.     /*----------------------------------------------------------------*/
  795.     /* Code Body                                                      */
  796.     /*----------------------------------------------------------------*/
  797.     return 0;
  798. }
  801. /*****************************************************************************
  802.  * FUNCTION
  803.  *  pFindNextEx
  804.  * DESCRIPTION
  805.  *  
  806.  * PARAMETERS
  807.  *  x1      [IN]        
  808.  *  x2      [?]         
  809.  *  x3      [IN]        
  810.  *  x4      [IN]        
  811.  * RETURNS
  812.  *  
  813.  *****************************************************************************/
  814. U8 pFindNextEx(FILE_HANDLE x1, void *x2, PS8 x3, U32 x4)
  815. {
  816.     /*----------------------------------------------------------------*/
  817.     /* Local Variables                                                */
  818.     /*----------------------------------------------------------------*/
  820.     /*----------------------------------------------------------------*/
  821.     /* Code Body                                                      */
  822.     /*----------------------------------------------------------------*/
  823.     return -1;
  824. }
  827. /*****************************************************************************
  828.  * FUNCTION
  829.  *  CloseFileFS
  830.  * DESCRIPTION
  831.  *  
  832.  * PARAMETERS
  833.  *  f       [IN]        
  834.  * RETURNS
  835.  *  void
  836.  *****************************************************************************/
  837. void CloseFileFS(FILE_HANDLE f)
  838. {
  839.     /*----------------------------------------------------------------*/
  840.     /* Local Variables                                                */
  841.     /*----------------------------------------------------------------*/
  843.     /*----------------------------------------------------------------*/
  844.     /* Code Body                                                      */
  845.     /*----------------------------------------------------------------*/
  846.     FS_Close(f);
  847. }
  850. /*****************************************************************************
  851.  * FUNCTION
  852.  *  WriteFileFS
  853.  * DESCRIPTION
  854.  *  
  855.  * PARAMETERS
  856.  *  buffer      [IN]        
  857.  *  size        [IN]        
  858.  *  count       [IN]        
  859.  *  f           [IN]        
  860.  * RETURNS
  861.  *  
  862.  *****************************************************************************/
  863. size_t WriteFileFS(const void *buffer, size_t size, size_t count, FILE_HANDLE f)
  864. {
  865.     /*----------------------------------------------------------------*/
  866.     /* Local Variables                                                */
  867.     /*----------------------------------------------------------------*/
  868.     U32 write;
  869.     int retval;
  871.     /*----------------------------------------------------------------*/
  872.     /* Code Body                                                      */
  873.     /*----------------------------------------------------------------*/
  874.     retval = FS_Write(f, (void*)buffer, size * count, &write);
  876.     if (retval == FS_NO_ERROR)
  878.         /* succeed */
  880.     {
  881.         return write;
  882.     }
  884.     else
  885.         /* fail */
  887.     {
  888.         return 0;
  889.     }
  890. }
  893. /*****************************************************************************
  894.  * FUNCTION
  895.  *  ReadFileFS
  896.  * DESCRIPTION
  897.  *  
  898.  * PARAMETERS
  899.  *  buffer      [?]         
  900.  *  size        [IN]        
  901.  *  count       [IN]        
  902.  *  f           [IN]        
  903.  *  read        [?]         
  904.  * RETURNS
  905.  *  
  906.  *****************************************************************************/
  907. size_t ReadFileFS(void *buffer, size_t size, size_t count, FILE_HANDLE f, size_t *read)
  908. {
  909.     /*----------------------------------------------------------------*/
  910.     /* Local Variables                                                */
  911.     /*----------------------------------------------------------------*/
  912.     U32 dummyread;
  913.     int retval;
  915.     /*----------------------------------------------------------------*/
  916.     /* Code Body                                                      */
  917.     /*----------------------------------------------------------------*/
  918.     if (read == NULL)
  920.     {
  921.         read = &dummyread;
  922.     }
  924.     retval = FS_Read(f, buffer, size * count, read);
  926.     if (retval != FS_NO_ERROR)
  928.         /* fail */
  930.     {
  931.         *read = EOF;
  932.     }
  934.     return *read;
  935. }
  938. /*****************************************************************************
  939.  * FUNCTION
  940.  *  CreateDir
  941.  * DESCRIPTION
  942.  *  
  943.  * PARAMETERS
  944.  *  pPath       [?]     
  945.  * RETURNS
  946.  *  
  947.  *****************************************************************************/
  948. S32 CreateDir(U8 *pPath)
  949. {
  950.     /*----------------------------------------------------------------*/
  951.     /* Local Variables                                                */
  952.     /*----------------------------------------------------------------*/
  953.     S32 nLen = 0;
  954.     S32 nCount = 0;
  955.     S32 nRetVal;
  956.     U16 nFirstTime = TRUE;
  957.     U8 aTempPath[150];
  959.     /*----------------------------------------------------------------*/
  960.     /* Code Body                                                      */
  961.     /*----------------------------------------------------------------*/
  962.     nLen = UCS2Strlen((PS8) pPath);
  963.     nLen *= ENCODING_LENGTH;
  964.     while (nCount < nLen)
  965.     {
  966.         if (pPath[nCount] == '\' && pPath[nCount + 1] == '')
  967.         {
  968.             if (!nFirstTime)
  969.             {
  970.                 aTempPath[nCount] = '';
  971.                 aTempPath[nCount + 1] = '';
  973.                 nRetVal = FS_CreateDir((U16*) aTempPath);
  974.                 //if(nRetVal<FS_NO_ERROR)   // vikram...08/11/2003
  975.                 //  return nRetVal;
  976.             }
  977.             else
  978.             {
  979.                 nFirstTime = FALSE;
  980.             }
  981.         }
  982.         aTempPath[nCount] = pPath[nCount];
  983.         aTempPath[nCount + 1] = pPath[nCount + 1];
  984.         nCount += 2;
  985.     }
  986.     aTempPath[nCount] = '';
  987.     aTempPath[nCount + 1] = '';
  989.     nRetVal = FS_CreateDir((U16*) aTempPath);
  991.     return nRetVal;
  992. }
  995. /*****************************************************************************
  996.  * FUNCTION
  997.  *  OpenCache
  998.  * DESCRIPTION
  999.  *  
  1000.  * PARAMETERS
  1001.  *  pFileName       [?]     
  1002.  *  nType           [?]     
  1003.  * RETURNS
  1004.  *  
  1005.  *****************************************************************************/
  1006. FILE_HANDLE OpenCache(U8 *pFileName, U8 *nType)
  1007. {
  1008.     /*----------------------------------------------------------------*/
  1009.     /* Local Variables                                                */
  1010.     /*----------------------------------------------------------------*/
  1011.     FILE_HANDLE file;
  1013.     /*----------------------------------------------------------------*/
  1014.     /* Code Body                                                      */
  1015.     /*----------------------------------------------------------------*/
  1016.     file = pfopen(pFileName, nType);
  1017.     if (pfOpenError(file))
  1018.     {
  1019.         return 0;
  1020.     }
  1021.     else
  1022.     {
  1023.         StartFileRead(file, 0);
  1024.     }
  1026.     return file;
  1028. }
  1030. #endif /* MMI_ON_WIN32 */ 
  1032. #ifndef MMI_ON_WIN32
  1035. /*****************************************************************************
  1036.  * FUNCTION
  1037.  *  CreateDir
  1038.  * DESCRIPTION
  1039.  *  
  1040.  * PARAMETERS
  1041.  *  pPath       [?]     
  1042.  * RETURNS
  1043.  *  
  1044.  *****************************************************************************/
  1045. S32 CreateDir(U8 *pPath)
  1046. {
  1047.     /*----------------------------------------------------------------*/
  1048.     /* Local Variables                                                */
  1049.     /*----------------------------------------------------------------*/
  1050.     S32 nLen = 0;
  1051.     S32 nCount = 0;
  1052.     S32 nRetVal;
  1053.     U16 nFirstTime = TRUE;
  1054.     U8 aTempPath[150];
  1056.     /*----------------------------------------------------------------*/
  1057.     /* Code Body                                                      */
  1058.     /*----------------------------------------------------------------*/
  1059.     nLen = UCS2Strlen((PS8) pPath);
  1060.     nLen *= ENCODING_LENGTH;
  1061.     while (nCount < nLen)
  1062.     {
  1063.         if (pPath[nCount] == '\' && pPath[nCount + 1] == '')
  1064.         {
  1065.             if (!nFirstTime)
  1066.             {
  1067.                 aTempPath[nCount] = '';
  1068.                 aTempPath[nCount + 1] = '';
  1070.                 nRetVal = FS_CreateDir((U16*) aTempPath);
  1071.                 //if(nRetVal<FS_NO_ERROR)   // vikram...08/11/2003
  1072.                 //  return nRetVal;
  1073.             }
  1074.             else
  1075.             {
  1076.                 nFirstTime = FALSE;
  1077.             }
  1078.         }
  1079.         aTempPath[nCount] = pPath[nCount];
  1080.         aTempPath[nCount + 1] = pPath[nCount + 1];
  1081.         nCount += 2;
  1082.     }
  1083.     aTempPath[nCount] = '';
  1084.     aTempPath[nCount + 1] = '';
  1086.     nRetVal = FS_CreateDir((U16*) aTempPath);
  1088.     return nRetVal;
  1089. }
  1092. /*****************************************************************************
  1093.  * FUNCTION
  1094.  *  OpenCache
  1095.  * DESCRIPTION
  1096.  *  
  1097.  * PARAMETERS
  1098.  *  pFileName       [?]         
  1099.  *  nType           [IN]        
  1100.  * RETURNS
  1101.  *  
  1102.  *****************************************************************************/
  1103. FILE_HANDLE OpenCache(U8 *pFileName, S32 nType)
  1104. {
  1105.     /*----------------------------------------------------------------*/
  1106.     /* Local Variables                                                */
  1107.     /*----------------------------------------------------------------*/
  1108.     FILE_HANDLE file;
  1110.     /*----------------------------------------------------------------*/
  1111.     /* Code Body                                                      */
  1112.     /*----------------------------------------------------------------*/
  1113.     file = pfopen(pFileName, nType);
  1114.     if (pfOpenError(file))
  1115.     {
  1116.         return NULL;
  1117.     }
  1118.     else
  1119.     {
  1120.         StartFileRead(file, 0);
  1121.     }
  1123.     return file;
  1125. }
  1127. #endif /* MMI_ON_WIN32 */