smplfsys.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:17k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _SMPLFSYS_H_
  36. #define _SMPLFSYS_H_
  37. #include <stdio.h>
  38. /****************************************************************************
  39.  * 
  40.  *  Function:
  41.  * 
  42.  * HXCreateInstance()
  43.  * 
  44.  *  Purpose:
  45.  * 
  46.  * Function implemented by all plugin DLL's to create an instance of 
  47.  * any of the objects supported by the DLL. This method is similar to 
  48.  * Window's CoCreateInstance() in its purpose, except that it only 
  49.  * creates objects from this plugin DLL.
  50.  *
  51.  * NOTE: Aggregation is never used. Therefore an outer unknown is
  52.  * not passed to this function, and you do not need to code for this
  53.  * situation.
  54.  * 
  55.  */
  56. STDAPI HXCreateInstance(IUnknown**  /*OUT*/ ppIUnknown);
  57. /****************************************************************************
  58.  * 
  59.  *  Function:
  60.  * 
  61.  * HXShutdown()
  62.  * 
  63.  *  Purpose:
  64.  * 
  65.  * Function implemented by all plugin DLL's to free any *global* 
  66.  * resources. This method is called just before the DLL is unloaded.
  67.  *
  68.  */
  69. STDAPI HXShutdown(void);
  70. // Forward declarations
  71. class CHXGenericCallback;
  72. #if defined(HELIX_FEATURE_PROGDOWN)
  73. class CProgressiveDownloadMonitor;
  74. #endif /* #if defined(HELIX_FEATURE_PROGDOWN) */
  75. /////////////////////////////////////////////////////////////////////////////
  76. // 
  77. //  Class:
  78. //
  79. //   CSimpleFileSystem
  80. //
  81. //  Purpose:
  82. //
  83. //   Example implementation of a basic file system.
  84. //
  85. class CSimpleFileSystem :   public IHXPlugin, 
  86.     public IHXFileSystemObject
  87. {
  88. private:
  89.     LONG32 m_lRefCount;
  90.     static const IID            zm_myIID;
  91.     static const char* const    zm_pDescription;
  92.     static const char* const    zm_pCopyright;
  93.     static const char* const    zm_pMoreInfoURL;
  94.     static const char* const    zm_pShortName;
  95.     static const char* const zm_pProtocol;
  96.     CHXString m_base_path;
  97.     IUnknown* m_pContext;
  98.     IHXValues* m_options;
  99.     UINT32 m_ulMaxIterationLevel;
  100. public:
  101.     CSimpleFileSystem();
  102.     ~CSimpleFileSystem();
  103.     BOOL m_bDisableMemoryMappedIO;
  104.     BOOL m_bEnableFileLocking;
  105.     UINT32 m_ulChunkSize;
  106.     IUnknown* m_pCommonObj;
  107.     // *** IUnknown methods ***
  108.     STDMETHOD(QueryInterface) (THIS_
  109.                     REFIID riid,
  110.                     void** ppvObj);
  111.     STDMETHOD_(ULONG32,AddRef) (THIS);
  112.     STDMETHOD_(ULONG32,Release) (THIS);
  113.     // *** IHXPlugin methods ***
  114.     /************************************************************************
  115.      * Method:
  116.      *     IHXPlugin::GetPluginInfo
  117.      * Purpose:
  118.      *     Returns the basic information about this plugin. Including:
  119.      *
  120.      *     bLoadMultiple whether or not this plugin DLL can be loaded
  121.      * multiple times. All File Formats must set
  122.      * this value to TRUE.
  123.      *     pDescription which is used in about UIs (can be NULL)
  124.      *     pCopyright which is used in about UIs (can be NULL)
  125.      *     pMoreInfoURL which is used in about UIs (can be NULL)
  126.      */
  127.     STDMETHOD(GetPluginInfo) (THIS_
  128. REF(BOOL)        /*OUT*/ bLoadMultiple,
  129. REF(const char*) /*OUT*/ pDescription,
  130. REF(const char*) /*OUT*/ pCopyright,
  131. REF(const char*) /*OUT*/ pMoreInfoURL,
  132. REF(ULONG32)  /*OUT*/ ulVersionNumber
  133. );
  134.     /************************************************************************
  135.      * Method:
  136.      *     IHXPlugin::InitPlugin
  137.      * Purpose:
  138.      *     Initializes the plugin for use. This interface must always be
  139.      *     called before any other method is called. This is primarily needed 
  140.      *     so that the plugin can have access to the context for creation of
  141.      *     IHXBuffers and IMalloc.
  142.      */
  143.     STDMETHOD(InitPlugin)   (THIS_
  144.     IUnknown*   /*IN*/  pContext);
  145.     // *** IHXFileSystemObject methods ***
  146.     STDMETHOD(GetFileSystemInfo)    (THIS_
  147.     REF(const char*) /*OUT*/ pShortName,
  148.     REF(const char*) /*OUT*/ pProtocol);
  149.     STDMETHOD(InitFileSystem) (THIS_ IHXValues* options);
  150.     STDMETHOD(CreateFile) (THIS_
  151. IUnknown**    /*OUT*/ ppFileObject);
  152.     STDMETHOD(CreateDir)        (THIS_
  153.                                 IUnknown**     /*OUT*/  ppDirObject);
  154. };
  155. #ifdef _MACINTOSH
  156. enum SeekReason
  157. {
  158.     REINIT_SEEK = 0,
  159.     EXTERNAL_SEEK,
  160.     PRE_TELL_SEEK,
  161.     POST_TELL_SEEK
  162. };
  163. #endif
  164. /////////////////////////////////////////////////////////////////////////////
  165. // 
  166. //  Class:
  167. //
  168. //   CSimpleFileObject
  169. //
  170. //  Purpose:
  171. //
  172. //   Example implementation of a basic file system file object.
  173. //
  174. class CSimpleFileObject :   public IHXFileObject, 
  175.     public IHXDirHandler,
  176.     public IHXFileStat,
  177.     public IHXFileExists,
  178.     public IHXGetFileFromSamePool,
  179.     public IHXRequestHandler,
  180.     public IHXFileRename,
  181.     public IHXFileRemove,
  182.     public IHXFileMove,
  183.     public IHXThreadSafeMethods
  184. #if defined(HELIX_FEATURE_PROGDOWN)
  185.                             , public CProgressiveDownloadMonitorResponse
  186. #endif /* #if defined(HELIX_FEATURE_PROGDOWN) */
  187. {
  188. private:
  189.     UINT32     m_ulSize;
  190.     UINT32     m_ulPos;
  191.     BOOL     m_bCanBeReOpened;
  192.     void     UpdateFileNameMember();
  193.     LONG32     m_lRefCount;
  194.     UINT32          m_ulFlags;
  195.     UINT32     m_ulMaxIterationLevel;
  196. #ifdef USE_THREADSAFE_SCHEDULER
  197.     IHXThreadSafeScheduler* m_pScheduler;
  198. #else
  199.     IHXScheduler*     m_pScheduler;
  200. #endif //USE_THREADSAFE_SCHEDULER
  201.     IUnknown*     m_pContext;
  202.     IHXCommonClassFactory* m_pCommonClassFactory;
  203.     IHXFileResponse*     m_pFileResponse;
  204.     CSimpleFileSystem*     m_pFileSystem;
  205.     IHXRequest*     m_pRequest;
  206.     IHXDescriptorRegistration* m_pDescriptorReg;
  207.     BOOL     m_bLocalClose;
  208.     IHXDirHandlerResponse* m_pDirResponse;
  209.     char*     m_pFilename;
  210. #ifdef _MACINTOSH
  211.     CMacAsyncFile*     m_pDataFile; /* cross-platform file object */
  212. #else
  213.     IHXDataFile*     m_pDataFile; /* cross-platform file object */
  214. #endif
  215.     int     m_nFd;
  216.     CHXString     m_base_path;
  217.     BOOL     m_bAsyncAccess;
  218.     BOOL     m_bInRead;
  219.     BOOL     m_bReadPending;
  220.     BOOL     m_bAsyncReadPending;
  221.     UINT32     m_ulPendingReadCount;
  222.     CFindFile*     m_pDirList;
  223.     IUnknown*     m_pUnknownUserContext;
  224.     UINT32                  m_ulPendingSeekOffset;
  225.     UINT16                  m_usPendingSeekWhence;
  226.     void GetFullPathname(const char* pPath, CHXString* pPathname);
  227.     BOOL     m_bReadCancelled;
  228.     HX_RESULT ActualAsyncReadDone(HX_RESULT result, IHXBuffer* pBuffer);
  229.     HX_RESULT ActualAsyncSeekDone(HX_RESULT result);
  230.     HX_RESULT DoRead(REF(BOOL) rbProgFail);
  231.     HX_RESULT DoSeek(REF(HX_RESULT) rSeekDoneResult);
  232.     void      SeekBackwards(UINT32 ulNumBytes);
  233.     HX_RESULT FinishDoRead(UINT32 actual, REF(IHXBuffer*) pBuffer);
  234. #ifdef _MACINTOSH
  235.     class SMPLAsyncResponse : public CMacAsyncFileResponse
  236.     {
  237.     public:
  238. SMPLAsyncResponse(CSimpleFileObject* pFileObject);
  239. ~SMPLAsyncResponse();
  240. HX_RESULT AsyncReadDone(HX_RESULT result, IHXBuffer* pBuffer);
  241. HX_RESULT AsyncSeekDone(HX_RESULT result);
  242. CSimpleFileObject*  m_pSMPLFileObject;
  243.     };
  244.     friend class SMPLAsyncResponse;
  245.     SMPLAsyncResponse*     m_pAsyncFileResponse;
  246.     IHXInterruptState*     m_pInterruptState;
  247.     IHXFileStatResponse*   m_pFileStatResponse;
  248.     SeekReason     m_eSeekReason;
  249.     UINT32     m_ulPreSeekPosition;
  250.     BOOL     m_bFileToBeClosed;
  251. #endif
  252.     CHXGenericCallback* m_pStackCallback;
  253. #if defined(HELIX_FEATURE_PROGDOWN)
  254.     enum
  255.     {
  256.         CallbackStateUnknown,
  257.         CallbackStateSeek,
  258.         CallbackStateRead
  259.     };
  260.     CProgressiveDownloadMonitor* m_pProgDownMon;
  261.     UINT32                       m_ulCallbackState;
  262.     BOOL                         RequireFullRead();
  263.     HX_RESULT                    FinishDoReadWithCallback(UINT32 actual);
  264.     HX_RESULT                    FinishDoReadWithoutCallback(UINT32 actual);
  265.     BOOL                         m_bProgDownEnabled;
  266. #endif /* #if defined(HELIX_FEATURE_PROGDOWN) */
  267. public:
  268.     CSimpleFileObject
  269.     (
  270. CHXString& base_path, 
  271. CSimpleFileSystem*, 
  272. IUnknown*,
  273. UINT32 ulMaxRecursionLevel
  274.     );
  275.     ~CSimpleFileObject();
  276.     /*
  277.      * IUnknown methods
  278.      */
  279.     STDMETHOD(QueryInterface) (THIS_
  280.                     REFIID riid,
  281.                     void** ppvObj);
  282.     STDMETHOD_(ULONG32,AddRef) (THIS);
  283.     STDMETHOD_(ULONG32,Release) (THIS);
  284.     /*
  285.      * IHXFileObject methods
  286.      */
  287.     /************************************************************************
  288.      * Method:
  289.      *     IHXFileObject::Init
  290.      * Purpose:
  291.      *     Associates a file object with the file response object it should
  292.      *     notify of operation completness. This method should also check
  293.      *     for validity of the object (for example by opening it if it is
  294.      *     a local file).
  295.      */
  296.     STDMETHOD(Init) (THIS_
  297. ULONG32     /*IN*/ ulFlags,
  298. IHXFileResponse*   /*IN*/ pFileResponse);
  299.     /************************************************************************
  300.      *  Method:
  301.      *      IHXFileObject::GetFilename
  302.      *  Purpose:
  303.      *      Returns the filename (without any path information) associated
  304.      *      with a file object.
  305.      */
  306.     STDMETHOD(GetFilename)      (THIS_
  307. REF(const char*)    /*OUT*/  pFilename);
  308.     /************************************************************************
  309.      * Method:
  310.      *     IHXFileObject::Close
  311.      * Purpose:
  312.      *     Closes the file resource and releases all resources associated
  313.      *     with the object.
  314.      */
  315.     STDMETHOD(Close)      (THIS);
  316.     /************************************************************************
  317.      * Method:
  318.      *     IHXFileObject::Read
  319.      * Purpose:
  320.      *     Reads a buffer of data of the specified length from the file
  321.      *     and asynchronously returns it to the caller via the 
  322.      *     IHXFileResponse interface passed in to Init.
  323.      */
  324.     STDMETHOD(Read) (THIS_
  325.                     ULONG32          ulCount);
  326.     /************************************************************************
  327.      * Method:
  328.      *     IHXFileObject::Write
  329.      * Purpose:
  330.      *     Writes a buffer of data to the file and asynchronously notifies
  331.      *     the caller via the IHXFileResponse interface passed in to Init,
  332.      *     of the completeness of the operation.
  333.      */
  334.     STDMETHOD(Write)      (THIS_
  335.                     IHXBuffer*     pBuffer);
  336.     /************************************************************************
  337.      * Method:
  338.      *     IHXFileObject::Seek
  339.      * Purpose:
  340.      *     Seeks to an offset in the file and asynchronously notifies
  341.      *     the caller via the IHXFileResponse interface passed in to Init,
  342.      *     of the completeness of the operation.
  343.      */
  344.     STDMETHOD(Seek) (THIS_
  345.                      ULONG32     ulOffset,
  346.  BOOL               bRelative);
  347.     /************************************************************************
  348.      * Method:
  349.      *     IHXFileObject::Stat
  350.      * Purpose:
  351.      *     Collects information about the file that is returned to the
  352.      *      caller in an IHXStat object
  353.      */
  354.     STDMETHOD(Stat) (THIS_
  355. IHXFileStatResponse* pFileStatResponse);
  356.     /************************************************************************
  357.      * Method:
  358.      *     IHXFileObject::Advise
  359.      * Purpose:
  360.      *      To pass information to the File Object
  361.      */
  362.     STDMETHOD(Advise) (THIS_
  363. ULONG32 ulInfo);
  364.     /************************************************************************
  365.      * Method:
  366.      *     IHXDirHandler::InitDirHandler
  367.      * Purpose:
  368.      *     Associates a directory handler with the directory handler
  369.      *     response, it should notify of operation completness.
  370.      */
  371.     STDMETHOD(InitDirHandler) (THIS_
  372. IHXDirHandlerResponse*    /*IN*/  pDirResponse);
  373.     /************************************************************************
  374.      * Method:
  375.      *     IHXDirHandler::CloseDirHandler
  376.      * Purpose:
  377.      *     Closes the directory handler resource and releases all resources
  378.      *     associated with the object.
  379.      */
  380.     STDMETHOD(CloseDirHandler) (THIS);
  381.     /************************************************************************
  382.      * Method:
  383.      *     IHXDirHandler::MakeDir
  384.      * Purpose:
  385.      *     Create the directory
  386.      */
  387.     STDMETHOD(MakeDir) (THIS);
  388.     /************************************************************************
  389.      * Method:
  390.      *     IHXDirHandler::ReadDir
  391.      * Purpose:
  392.      *     Get a dump of the directory
  393.      */
  394.     STDMETHOD(ReadDir) (THIS);
  395.     /************************************************************************
  396.      * Method:
  397.      *     IHXGetFileFromSamePool::GetFileObjectFromPool
  398.      * Purpose:
  399.      *      To get another FileObject from the same pool. 
  400.      */
  401.     STDMETHOD(GetFileObjectFromPool) (THIS_
  402.  IHXGetFileFromSamePoolResponse*);
  403.     // IHXFileExists interface
  404.     /************************************************************************
  405.      * Method:
  406.      *     IHXFileExists::DoesExist
  407.      * Purpose:
  408.      */
  409.     STDMETHOD(DoesExist) (THIS_
  410. const char* /*IN*/  pPath, 
  411. IHXFileExistsResponse* /*IN*/  pFileResponse);
  412.     //IHXRequestHandler methods
  413.     /************************************************************************
  414.      * Method:
  415.      *     IHXRequestHandler::SetRequest
  416.      * Purpose:
  417.      *     Associates an IHXRequest with an object
  418.      */
  419.     STDMETHOD(SetRequest)    (THIS_
  420.      IHXRequest*        /*IN*/  pRequest);
  421.     /************************************************************************
  422.      * Method:
  423.      *     IHXRequestHandler::GetRequest
  424.      * Purpose:
  425.      *     Gets the IHXRequest object associated with an object
  426.      */
  427.     STDMETHOD(GetRequest)    (THIS_
  428.      REF(IHXRequest*)  /*OUT*/  pRequest);
  429.     /************************************************************************
  430.      * Method:
  431.      *     IHXFileRename::Rename
  432.      * Purpose:
  433.      *     Renames the file to the new file name
  434.      */
  435.     STDMETHOD(Rename) (THIS_
  436. const char* /*IN*/  pFilename);
  437.     /************************************************************************
  438.      * Method:
  439.      *     IHXFileMove::Move
  440.      * Purpose:
  441.      *     Renames the file to the new file name
  442.      */
  443.     STDMETHOD(Move) (THIS_
  444. const char* /*IN*/  pFilename);
  445.     /************************************************************************
  446.      * Method:
  447.      *     IHXFileRemove::Remove
  448.      * Purpose:
  449.      *     Removes the file from the file system
  450.      */
  451.     STDMETHOD(Remove) (THIS);
  452.     /************************************************************************
  453.      * Method:
  454.      *     Private interface::_OpenFile
  455.      * Purpose:
  456.      *     This common method is used from Init() and GetFileObjectFromPool()
  457.      */
  458.     STDMETHOD(_OpenFile) (THIS_
  459.   ULONG32     ulFlags);
  460.     STDMETHOD_(UINT32,IsThreadSafe)(THIS);
  461. #if defined(HELIX_FEATURE_PROGDOWN)
  462.     // CProgressiveDownloadMonitorResponse methods
  463.     STDMETHOD(ProgressiveCallback) (THIS);
  464. #endif /* #if defined(HELIX_FEATURE_PROGDOWN) */
  465.     // CSimpleFileObject methods
  466.     static void StackCallback(void* pArg);
  467. };
  468. #endif // ndef _SMPLFSYS_H_