symbihxdataf.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:13k
源码类别:

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. /****************************************************************************
  36.  *  Includes
  37.  */
  38. #include "hlxclib/string.h"
  39. #include "hlxclib/fcntl.h"
  40. #include "hxbuffer.h"
  41. #include "hxassert.h"
  42. #include "hlxosstr.h"
  43. #include "hxstrutl.h"
  44. #include "symbihxdataf.h"
  45. #include "symbsessionmgr.h"
  46. /****************************************************************************
  47.  *  CSymbIHXDataFile
  48.  */
  49. /****************************************************************************
  50.  *  Constructor/Destructor
  51.  */
  52. CSymbIHXDataFile::CSymbIHXDataFile(IUnknown** ppCommonObj)
  53.     : m_pFileName(NULL)
  54.     , m_pSessionManager(NULL)
  55.     , m_bHaveSession(FALSE)
  56.     , m_bOpen(FALSE)
  57.     , m_symbLastError(KErrNone)
  58.     , m_lRefCount(0)
  59. {
  60.     CSymbSessionMgr::Create(m_pSessionManager, ppCommonObj);
  61. }
  62. CSymbIHXDataFile::~CSymbIHXDataFile(void)
  63. {
  64.     Close();
  65.     HX_RELEASE(m_pFileName);
  66.     HX_RELEASE(m_pSessionManager);
  67. }
  68. /****************************************************************************
  69.  *  IHXDataFile methods
  70.  */
  71. STDMETHODIMP_(void) CSymbIHXDataFile::Bind(const char* pFileName)
  72. {
  73.     m_symbLastError = KErrNone;
  74.     if (!m_pFileName)
  75.     {
  76. m_pFileName = new CHXBuffer;
  77. if (m_pFileName)
  78. {
  79.          m_pFileName->AddRef();
  80. }
  81.     }
  82.     Close();
  83.     if (m_pFileName && pFileName)
  84.     {
  85. if (m_pFileName->Set((UINT8*) pFileName, ::strlen(pFileName) + 1) != HXR_OK)
  86. {
  87.     HX_RELEASE(m_pFileName);
  88. }
  89.     }
  90. }
  91. HX_RESULT CSymbIHXDataFile::_Create(UINT16 uOpenMode, BOOL bCreateFile)
  92. {
  93.     HX_RESULT retVal = HXR_FAIL;
  94.     Close();
  95.     if (m_pFileName && (m_pFileName->GetSize() != 0) && GetSession())
  96.     {
  97. OS_STRING_TYPE osFileName(m_pFileName->GetBuffer());
  98. TPtrC symbNameDesc((TText*) ((OS_TEXT_PTR) osFileName));
  99. TUint symbFileMode = TranslateOpenMode(uOpenMode);
  100. if (bCreateFile)
  101. {
  102.     m_symbLastError = m_symbFile.Create(m_symbSession, 
  103. symbNameDesc,
  104. symbFileMode);
  105.     if ((m_symbLastError != KErrNone) && 
  106. !(uOpenMode & HX_FILEFLAG_NOTRUNC))
  107.     {
  108. m_symbSession.Delete(symbNameDesc);
  109. m_symbLastError = m_symbFile.Create(m_symbSession, 
  110.     symbNameDesc,
  111.     symbFileMode);
  112.     }
  113. }
  114. else
  115. {
  116.     m_symbLastError = m_symbFile.Open(m_symbSession, 
  117.       symbNameDesc,
  118.       symbFileMode);
  119. }
  120. if (m_symbLastError == KErrNone)
  121. {
  122.     m_bOpen = TRUE;
  123.     retVal = HXR_OK;
  124. }
  125.     }
  126.     return retVal;
  127. }
  128. STDMETHODIMP CSymbIHXDataFile::Create(UINT16 uOpenMode)
  129. {
  130.    return _Create(uOpenMode, TRUE);
  131. }
  132. STDMETHODIMP CSymbIHXDataFile::Open(UINT16 uOpenMode)
  133. {
  134.    return _Create(uOpenMode, FALSE);
  135. }
  136. STDMETHODIMP CSymbIHXDataFile::Close()
  137. {
  138.     HX_RESULT retVal = HXR_OK;
  139.     m_symbLastError = KErrNone;
  140.     if (m_bOpen)
  141.     {
  142. retVal = HXR_FAIL;
  143. if ((m_symbLastError = m_symbFile.Flush()) == KErrNone)
  144. {
  145.     retVal = HXR_OK;
  146. }
  147. m_symbFile.Close();
  148. m_bOpen = FALSE;
  149.     }
  150.     return retVal;
  151. }
  152. STDMETHODIMP_(BOOL) CSymbIHXDataFile::Name(REF(IHXBuffer*) pFileName)
  153. {
  154.     m_symbLastError = KErrNotReady;
  155.     if (m_pFileName && (m_pFileName->GetSize() != 0))
  156.     {
  157. m_symbLastError = KErrNone;
  158. pFileName = m_pFileName;
  159. pFileName->AddRef();
  160. return TRUE;
  161.     }
  162.     return FALSE;
  163. }
  164. STDMETHODIMP_(BOOL) CSymbIHXDataFile::IsOpen()
  165. {
  166.     m_symbLastError = KErrNone;
  167.     return m_bOpen;
  168. }
  169. STDMETHODIMP CSymbIHXDataFile::Seek(ULONG32 offset, UINT16 fromWhere)
  170. {
  171.     HX_RESULT retVal = HXR_FAIL;
  172.     TSeek symbSeekMode = TranslateSeekMode(fromWhere);
  173.     TInt symbOffset = (TInt) offset;
  174.     m_symbLastError = KErrNotReady;
  175.     if (m_bOpen && ((m_symbLastError = m_symbFile.Seek(symbSeekMode, symbOffset)) == KErrNone))
  176.     {
  177. retVal = HXR_OK;
  178.     }
  179.     return retVal;
  180. }
  181. STDMETHODIMP_(ULONG32) CSymbIHXDataFile::Tell()
  182. {
  183.     TInt symbOffset = 0;
  184.     m_symbLastError = KErrNotReady;
  185.     if (m_bOpen)
  186.     {
  187. m_symbLastError = m_symbFile.Seek(ESeekCurrent, symbOffset);
  188.     }
  189.     return (ULONG32) symbOffset;
  190. }
  191. STDMETHODIMP_(ULONG32) CSymbIHXDataFile::Read(REF(IHXBuffer*) pBuf,
  192.       ULONG32 ulSize)
  193. {
  194.     ULONG32 ulBytesRead = 0;
  195.     m_symbLastError = KErrNotReady;
  196.     if (m_bOpen)
  197.     {
  198. IHXBuffer* pNewBuffer = (IHXBuffer*) new CHXBuffer();
  199. if (pNewBuffer)
  200. {
  201.     pNewBuffer->AddRef();
  202.     if (pNewBuffer->SetSize(ulSize) == HXR_OK)
  203.     {
  204. TPtr8 symbBufferDesc((TUint8*) pNewBuffer->GetBuffer(), 
  205.      (TInt) ulSize);
  206. if ((m_symbLastError = m_symbFile.Read(symbBufferDesc)) == KErrNone)
  207. {
  208.     ulBytesRead = symbBufferDesc.Length();
  209.     
  210.     if (ulBytesRead == ulSize)
  211.     {
  212. pBuf = pNewBuffer;
  213. pNewBuffer = NULL;
  214.     }
  215.     else
  216.     {
  217. if (ulBytesRead < ulSize)
  218. {
  219.     if (pNewBuffer->SetSize(ulBytesRead) == HXR_OK)
  220.     {
  221. pBuf = pNewBuffer;
  222. pNewBuffer = NULL;
  223.     }
  224. }
  225. if (pNewBuffer)
  226. {
  227.     ulBytesRead = 0;
  228. }
  229.     }
  230. }
  231.     }
  232. }
  233. HX_RELEASE(pNewBuffer);
  234.     }
  235.     return ulBytesRead;
  236. }
  237. STDMETHODIMP_(ULONG32) CSymbIHXDataFile::Write(REF(IHXBuffer*) pBuf)
  238. {
  239.     ULONG32 ulBytesWritten = 0;
  240.     ULONG32 ulBytesToWrite = pBuf->GetSize();
  241.     
  242.     m_symbLastError = KErrNotReady;
  243.     if (m_bOpen)
  244.     {
  245. TPtrC8 symbBufferDesc((TUint8*) pBuf->GetBuffer(), 
  246.       (TInt) ulBytesToWrite);
  247. if ((m_symbLastError = m_symbFile.Write(symbBufferDesc)) == KErrNone)
  248. {
  249.     ulBytesWritten = ulBytesToWrite;
  250. }
  251.     }
  252.     return ulBytesWritten;
  253. }
  254. STDMETHODIMP CSymbIHXDataFile::Flush()
  255. {
  256.     HX_RESULT retVal = HXR_FAIL;
  257.     m_symbLastError = KErrNotReady;
  258.     if (m_bOpen && ((m_symbLastError = m_symbFile.Flush()) == KErrNone))
  259.     {
  260. retVal = HXR_OK;
  261.     }
  262.     return retVal;
  263. }
  264. STDMETHODIMP CSymbIHXDataFile::Stat(struct stat* pStatBuffer)
  265. {
  266.     TInt symbSize = 0;
  267.     BOOL bWasOpen = m_bOpen;
  268.     HX_RESULT retVal = HXR_OK;
  269.     
  270.     if (!m_bOpen)
  271.     {
  272. retVal = Open(HX_FILEFLAG_READ | HX_FILEFLAG_BINARY);
  273.     }
  274.     if (bWasOpen)
  275.     {
  276. retVal = HXR_FAIL;
  277. if ((m_symbLastError = m_symbFile.Flush()) == KErrNone)
  278. {
  279.     retVal = HXR_OK;
  280. }
  281.     }
  282.     if (retVal == HXR_OK)
  283.     {
  284. retVal = HXR_FAIL;
  285. if ((m_symbLastError = m_symbFile.Size(symbSize)) == KErrNone)
  286. {
  287.     retVal = HXR_OK;
  288. }
  289.     }
  290.     if (retVal == HXR_OK)
  291.     {
  292. pStatBuffer->st_mode = 0;
  293. pStatBuffer->st_size = symbSize;
  294. pStatBuffer->st_atime = 0;
  295. pStatBuffer->st_ctime = 0;
  296. pStatBuffer->st_mtime = 0;
  297.     }
  298.     if (!bWasOpen)
  299.     {
  300. Close();
  301.     }
  302.     return retVal;
  303. }
  304. STDMETHODIMP CSymbIHXDataFile::Delete()
  305. {
  306.     HX_RESULT retVal = HXR_FAIL;
  307.     m_symbLastError = KErrNotReady;
  308.     Close();
  309.     if (m_pFileName && (m_pFileName->GetSize() != 0) && GetSession())
  310.     {
  311. OS_STRING_TYPE osFileName(m_pFileName->GetBuffer());
  312. TPtrC symbNameDesc((TText*) ((OS_TEXT_PTR) osFileName));
  313. if ((m_symbLastError = m_symbSession.Delete(symbNameDesc)) == KErrNone)
  314. {
  315.     retVal = HXR_OK;
  316. }
  317.     }
  318.     return retVal;
  319. }
  320. STDMETHODIMP_(INT16) CSymbIHXDataFile::GetFd()
  321. {
  322.     INT16 iFd = -1;
  323.     m_symbLastError = KErrNotReady;
  324.     if (m_bOpen)
  325.     {
  326. m_symbLastError = KErrNone;
  327. iFd = (INT16) m_symbFile.SubSessionHandle();
  328.     }
  329.     return iFd;
  330. }
  331. STDMETHODIMP CSymbIHXDataFile::GetLastError(void)
  332. {
  333.     HX_RESULT retVal = (m_symbLastError == KErrNone) ? HXR_OK : HXR_FAIL;
  334.     return retVal;
  335. }
  336. STDMETHODIMP_(void) CSymbIHXDataFile::GetLastError(REF(IHXBuffer*) err)
  337. {
  338.     ;
  339. }
  340. /************************************************************************
  341.  *  IHXAsyncDataFile methods
  342.  */
  343. STDMETHODIMP CSymbIHXDataFile::SetReceiver(IHXCallback* pCallback)
  344. {
  345.     return HXR_NOTIMPL;
  346. }
  347. STDMETHODIMP CSymbIHXDataFile::SeekAsync(REF(HX_RESULT) status, 
  348.  ULONG32 offset, UINT16 fromWhere)
  349. {
  350.     return HXR_NOTIMPL;
  351. }
  352. STDMETHODIMP CSymbIHXDataFile::ReadAsync(REF(ULONG32) ulReadSize,
  353.  REF(IHXBuffer*) pBuf, 
  354.  ULONG32 count)
  355. {
  356.     return HXR_NOTIMPL;
  357. }
  358. STDMETHODIMP CSymbIHXDataFile::WriteAsync(REF(ULONG32) ulWrittenSize,
  359.   REF(IHXBuffer*) pBuf)
  360. {
  361.     return HXR_NOTIMPL;
  362. }
  363. /****************************************************************************
  364.  *  CSymbIHXDataFile custom public methods
  365.  */
  366. void CSymbIHXDataFile::Bind(IHXBuffer *pFileNameBuffer)
  367. {
  368.     Close();
  369.     HX_RELEASE(m_pFileName);
  370.     m_pFileName = pFileNameBuffer;
  371.     if (m_pFileName)
  372.     {
  373. m_pFileName->AddRef();
  374.     }
  375. }
  376. BOOL CSymbIHXDataFile::GetTemporaryFileName(const char *tag, char* filename, UINT32 ulBufLen)
  377. {
  378.     BOOL bRetVal = FALSE;
  379.     if (GetSession())
  380.     {
  381. TFileName* psymbTempPath = new TFileName;
  382. if (m_symbSession.DefaultPath(*psymbTempPath) == KErrNone)
  383. {
  384.     TFileName* psymbTempFileName = new TFileName;
  385.     if (psymbTempFileName)
  386.     {
  387. RFile symbTempFile;
  388. if (symbTempFile.Temp(m_symbSession, 
  389.       *psymbTempPath, 
  390.       *psymbTempFileName, 
  391.       EFileShareExclusive) == KErrNone)
  392. {
  393.     filename[0] = '';
  394.     SafeStrCpy(filename, 
  395.        OS_STRING2((OS_TEXT_PTR) psymbTempFileName->Ptr(), 
  396.   psymbTempFileName->Length()), 
  397.        ulBufLen);
  398.     symbTempFile.Close();
  399.     m_symbSession.Delete(*psymbTempFileName);
  400.     bRetVal = TRUE;
  401. }
  402. delete psymbTempFileName;
  403.     }
  404. }
  405. HX_DELETE(psymbTempPath);
  406.     }
  407.     return bRetVal;
  408. }
  409. /************************************************************************
  410.  *  Private methods
  411.  */
  412. TUint CSymbIHXDataFile::TranslateOpenMode(UINT16 uOpenMode)
  413. {
  414.     TUint symbMode = EFileShareAny;
  415.     
  416.     if (uOpenMode & HX_FILEFLAG_WRITE)
  417.     {
  418. symbMode |= EFileWrite;
  419.     }
  420.     else if (uOpenMode & HX_FILEFLAG_READ)
  421.     {
  422. symbMode |= EFileRead;
  423.     }
  424.     
  425.     if (uOpenMode & HX_FILEFLAG_BINARY)
  426.     {
  427. symbMode |= EFileStream;
  428.     }
  429.     return symbMode;
  430. }
  431. TSeek CSymbIHXDataFile::TranslateSeekMode(UINT16 fromWhere)
  432. {
  433.     switch (fromWhere)
  434.     {
  435.     case SEEK_SET:
  436. return ESeekStart;
  437.     case SEEK_CUR:
  438. return ESeekCurrent;
  439.     }
  440.     return ESeekEnd;
  441. }
  442. BOOL CSymbIHXDataFile::GetSession(void)
  443. {
  444.     if (m_bHaveSession)
  445.     {
  446. // Assume single thread usage for now
  447. return TRUE;
  448.     }
  449.     else if (m_pSessionManager)
  450.     {
  451. m_bHaveSession = 
  452.     (m_pSessionManager->GetSession(m_symbSession) == HXR_OK);
  453.     }
  454.     
  455.     return m_bHaveSession;
  456. }
  457. /************************************************************************
  458.  *  IUnknown methods
  459.  */
  460. STDMETHODIMP CSymbIHXDataFile::QueryInterface(REFIID riid, void** ppvObj)
  461. {
  462. QInterfaceList qiList[] =
  463. {
  464. { GET_IIDHANDLE(IID_IUnknown), (IUnknown*) this },
  465. { GET_IIDHANDLE(IID_IHXDataFile), (IHXDataFile*) this },
  466. };
  467.     return QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  468. }
  469. STDMETHODIMP_(ULONG32) CSymbIHXDataFile::AddRef()
  470. {
  471.     return InterlockedIncrement(&m_lRefCount);
  472. }
  473. STDMETHODIMP_(ULONG32) CSymbIHXDataFile::Release()
  474. {
  475.     if (InterlockedDecrement(&m_lRefCount) > 0)
  476.     {
  477.         return m_lRefCount;
  478.     }
  479.     delete this;
  480.     return 0;
  481. }