hxresmg.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

    return rc;
}

IHXBuffer* 
HXExternalResourceManager::ConvertToAsciiString(char* pBuffer, UINT32 nBuffLen)
{
    char* pOut = new char[nBuffLen*2+1];
    char* pStartOut = pOut;
    char Nibble;

    IHXBuffer* pOutBuffer = new CHXBuffer;
    pOutBuffer->AddRef();

    for (int i = 0; i < (int)nBuffLen; i++)
    {
	Nibble = (*pBuffer >> 4) & 15;
	*pOut= (Nibble > 9 ) ? Nibble + 55 : Nibble + 48;
	pOut++;
	Nibble = *pBuffer & 15;
	*pOut= (Nibble > 9 ) ? Nibble + 55 : Nibble + 48;
	pOut++;
	pBuffer++;
    }
    *pOut = 0;
    pOutBuffer->Set((UCHAR*)pStartOut, strlen(pStartOut)+1);
    delete[] pStartOut;
    return pOutBuffer;
}

IHXBuffer* 
HXExternalResourceManager::ChecksumFile(const char* pPath)
{
    struct stat	    stat_struct;
    md5_state_t	    MD5_data;
    UCHAR	    tempbuf[16];

    md5_init(&MD5_data);
    if (HXR_OK != Stat(pPath, &stat_struct))
    {
        md5_finish(tempbuf, &MD5_data);
	return NULL;
    } 
    md5_append(&MD5_data,(UCHAR*)&(stat_struct),sizeof(stat_struct)); 
    md5_finish(tempbuf, &MD5_data);
    return ConvertToAsciiString((char*)tempbuf, sizeof(tempbuf));
}

HX_RESULT
HXExternalResourceManager::SaveFileInfo(const char* pFileName,
				         const char* pPath)
{
    HX_RESULT rc = HXR_OK;

   // set/reset cache info
    if(!m_pPrefs)
    {
	return HXR_FAIL;
    }

    IHXBuffer* pStatInfo = ChecksumFile(pPath);
    if(pStatInfo)
    {
	CHXString prefString;
	prefString.Format("%s\\%s\\%s\\%s",
			    EXT_RES_DATA_KEY,
			    FILE_INFO_KEY,
			    pFileName,
			    CHECKSUM_KEY);
	m_pPrefs->WritePref(prefString, pStatInfo);
	HX_RELEASE(pStatInfo);
    }

    // now write out the langages supported in the resource file
    IHXXResFile* pResFile;
    if(HXR_OK == m_pHXXResPlugin->QueryInterface(IID_IHXXResFile, 
						(void**)&pResFile))
    {
	HX_RESULT rc = HXR_OK;

	// open res file and iterate through all of the languages
	// it supports
	pResFile->Open(pPath);

	UINT32 ulLangID = 0;
	rc = pResFile->GetFirstResourceLanguage(ulLangID);
	while(HXR_OK == rc)
	{
	    CHXString prefString;
	    IHXBuffer* pBuffer = new CHXBuffer;
	    prefString.Format("%s\\%s\\%s\\%s\\%ld",
				EXT_RES_DATA_KEY,
				FILE_INFO_KEY,
				pFileName,
				LANGUAGE_KEY,
				ulLangID);
	    pBuffer->Set((BYTE*)"", 1);
	    m_pPrefs->WritePref(prefString, pBuffer);
	    HX_RELEASE(pBuffer);

	    rc = pResFile->GetNextResourceLanguage(ulLangID);
	};
	HX_RELEASE(pResFile);
    }

    return rc;
}

HX_RESULT
HXExternalResourceManager::LoadResourceFile(const char* pPath)
{
    HX_RESULT rc = HXR_OK;

    // MakeResFileObject only returns an IHXXResFile
    // if there are any resources in the current language
    IHXXResFile* pResFile = MakeResFileObject(pPath);
    if (pResFile)
    {
	if(!m_pResourceList)
	{
	    m_pResourceList = new CHXSimpleList;
	}
    	m_pResourceList->AddTail(pResFile);
    }

    return rc;
}

BOOL
HXExternalResourceManager::FileInfoCurrent(const char* pFileName, 
					    const char* pPath)
{
    BOOL rc = FALSE;

    IHXBuffer* pStatInfo = ChecksumFile(pPath);
    if(pStatInfo)
    {
	IHXBuffer* pPrefValue = NULL;
	CHXString prefString;
	prefString.Format("%s\\%s\\%s\\%s",
			    EXT_RES_DATA_KEY,
			    FILE_INFO_KEY,
			    pFileName,
			    CHECKSUM_KEY);
	if(HXR_OK == m_pPrefs->ReadPref(prefString, pPrefValue) &&
	    pPrefValue)
	{
	    const char* pActualPrefValue = (const char*)pPrefValue->GetBuffer();
	    const char* pActualStatInfo = (const char*)pStatInfo->GetBuffer();
	    if(strcmp(pActualPrefValue, pActualStatInfo) == 0)
	    {
		rc = TRUE;
	    }
	    HX_RELEASE(pPrefValue);
	}
	HX_RELEASE(pStatInfo);
    }

    return rc;
}

BOOL
HXExternalResourceManager::ContainsCurrentLanguage(const char* pFileName,
						   const char* pPath)
{
#if defined (_MACINTOSH) || defined (_UNIX)
    /* Temporary - Mac Installer does not write this pref yet -- XXXRA */	
    return TRUE;
#endif

    BOOL rc = FALSE;

    IHXBuffer* pLangInfo = NULL;
    CHXString prefString;
    prefString.Format("%s\\%s\\%s\\%s\\%ld",
			EXT_RES_DATA_KEY,
			FILE_INFO_KEY,
			pFileName,
			LANGUAGE_KEY,
			m_ulLanguageID);
    if(HXR_OK == m_pPrefs->ReadPref(prefString, pLangInfo))
    {
	rc = TRUE;
	HX_RELEASE(pLangInfo);
    }

    return rc;
}

HX_RESULT
HXExternalResourceManager::LoadResourceFiles()
{
    CFindFile*	pFileFinder	= NULL;
    char*	pResFile	= NULL;
    const char*	pFileExtension	= "*.xrs";
    HX_RESULT   rc		= HXR_OK;

    // find plugins with specified pattern
    pFileFinder = CFindFile::CreateFindFile(m_pExternalResDir, 0, 
					    pFileExtension);
    if (NULL == pFileFinder)
    {
	rc = HXR_FAIL;
	goto cleanup;
    }

    // collect plugin info.
    pResFile = pFileFinder->FindFirst();
    while (pResFile)
    {
	BOOL bLoadFile = FALSE;
	const char* pResPath = pFileFinder->GetCurFilePath();
	// only load the file if it has resources that reflect
	// the current system language ID
	if(!FileInfoCurrent(pResFile, pResPath))
	{
	    SaveFileInfo(pResFile, pResPath);
	}
	    
	if(ContainsCurrentLanguage(pResFile, pResPath))
	{
	    rc = LoadResourceFile(pResPath);
	}
	if(HXR_OK != rc)
	{
	    // error - log it and keep on?
	}
	pResFile = pFileFinder->FindNext();
    }
    delete pFileFinder;

cleanup:
    return rc;
}

// HXExternalResourceReader methods

HXExternalResourceReader::HXExternalResourceReader(
				     HXExternalResourceManager* pMgr):
     m_lRefCount(0)
    ,m_pResManager(pMgr)
    ,m_pResourceList(NULL)
    ,m_pDefaultRes(NULL)
{
}

HXExternalResourceReader::~HXExternalResourceReader()
{
    HX_DELETE(m_pResourceList);
    HX_RELEASE(m_pDefaultRes);
}

// IUnknown methods

STDMETHODIMP 
HXExternalResourceReader::QueryInterface(REFIID riid, void** ppvObj)
{
    QInterfaceList qiList[] =
        {
            { GET_IIDHANDLE(IID_IHXExternalResourceReader), (IHXExternalResourceReader*)this },
            { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXExternalResourceReader*)this },
        };
    
    return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
}

STDMETHODIMP_(ULONG32) 
HXExternalResourceReader::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

STDMETHODIMP_(ULONG32) 
HXExternalResourceReader::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
	return m_lRefCount;
    }

    delete this;
    return 0;
}


STDMETHODIMP
HXExternalResourceReader::SetDefaultResourceFile(
			    const char* pResourcePath)
{
    HX_RESULT rc = HXR_OK;

    m_pDefaultRes = m_pResManager->MakeResFileObject(pResourcePath);

    return rc;
}

IHXXResource*
HXExternalResourceReader::GetResource(IHXXResFile* pResFile,
				       UINT32 ulResourceType,
				       UINT32 ulResourceID)
{
    IHXXResource* pRes = NULL;
    switch(ulResourceType)
    {
	case HX_RT_STRING:
	{
	    pRes = pResFile->GetString(ulResourceID);
	}
	break;

	case HX_RT_DIALOG:
	{
	    pRes = pResFile->GetDialog(ulResourceID);
	}
	break;

	case HX_RT_BITMAP:
	{
	    pRes = pResFile->GetBitmap(ulResourceID);
	}
	break;

	default:
	break;
    }
    return pRes;
}

STDMETHODIMP_(IHXXResource*)
HXExternalResourceReader::GetResource(UINT32 ulResourceType,
				    UINT32 ulResourceID)
{
    IHXXResource* pRes = NULL;

    if(m_pResourceList)
    {
	CHXSimpleList::Iterator i = m_pResourceList->Begin();
	for (; i != m_pResourceList->End(); ++i)
	{
	    IHXXResFile* pResFile = (IHXXResFile*)(*i);
	    pRes = GetResource(pResFile, ulResourceType, ulResourceID);
	    if(pRes)
	    {
		break;
	    }
	}
    }

    if(!pRes &&
	m_pDefaultRes)	// check default
    {
	pRes = GetResource(m_pDefaultRes, ulResourceType, ulResourceID);
    }

    return pRes;
}


HX_RESULT
HXExternalResourceReader::Init(const char* pShortName,
				CHXSimpleList* pResList)
{
    HX_RESULT rc = HXR_OK;

    if(pResList)
    {
	CHXSimpleList::Iterator i = pResList->Begin();
	for (; i != pResList->End(); ++i)
	{
	    IHXXResFile* pResFile = (IHXXResFile*)(*i);
	    if(pResFile->IncludesShortName(pShortName))
	    {
		if(!m_pResourceList)
		{
		    m_pResourceList = new CHXSimpleList;
		}
		m_pResourceList->AddTail(pResFile);
	    }
	}
    }

    return rc;
}