// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <barsc2.h>

 #include "BaArchiveImpl.h"

 #include <baflpan.h>

 #include <bautils.h>

 /** TCleanupItem function.

 @internalComponent

 */

 LOCAL_C void CloseAndDeleteFile(TAny* aFile)

 	{

 	RFile* const file=static_cast<RFile*>(aFile);

 	if (file!=NULL)

 		{

 		file->Close();

 		delete file;

 		}

 	}

 /** TCleanupItem function.

 @internalComponent

 */

 LOCAL_C void CloseAndDeleteChunk(TAny* aChunk)

 	{

 	RChunk* const rchunk=static_cast<RChunk*>(aChunk);

 	if (rchunk!=NULL)

 		{

 		rchunk->Close();

 		delete rchunk;

 		}

 	}

 /** Default Constructor

 @internalComponent

 */

 CResourceArchiveImpl::CResourceArchiveImpl() :

 	iCurrentIndex(0),

 	iSpiFileType(KNullUid)

 	{}

 /** Class destructor

 @internalComponent 

 */

 CResourceArchiveImpl::~CResourceArchiveImpl()

 	{

 	iRscList.Close();

 	for(TInt i=0; i<iSpiChunkBufferArray.Count(); i++)

 		{

 		RChunk* const chunk = iSpiChunkBufferArray[i];                     

 		chunk->Close();

 		delete chunk;

 		}

 	iSpiChunkBufferArray.Reset();

 	iSpiChunkBufferArray.Close();

 	iSpiBufferArray.ResetAndDestroy();

 	iSpiBufferArray.Close();

 	iCurrentIndex=0;

 	iSpiFileType=KNullUid;

 #ifdef __BASPITEST__

 	iSpiFileNameArray.Reset();

 	iSpiFileNameArray.Close();

 #endif	

 	}

 /** Creates a CResourceArchiveImpl instance to read a single spi file

 @internalComponent

 */

 CResourceArchiveImpl* CResourceArchiveImpl::NewL(RFs& aFs,const TDesC& aName)

 	{

 	CResourceArchiveImpl* self=new (ELeave) CResourceArchiveImpl;

 	CleanupStack::PushL(self);

 	self->ConstructL(aFs,aName);

 	CleanupStack::Pop();

 	return self;

 	}

 /** Creates a CResourceArchiveImpl instance to read a set of spi files

 @internalComponent

 */	

 CResourceArchiveImpl* CResourceArchiveImpl::NewL(RFs& aFs,const TDesC& aPath,const TDesC& aPattern)

 	{

 	CResourceArchiveImpl* self=new (ELeave) CResourceArchiveImpl;

 	CleanupStack::PushL(self);

 	self->ConstructL(aFs,aPath,aPattern);

 	CleanupStack::Pop();

 	return self;	

 	}

 /** ConstructL method of CResourceArchiveImpl

 @internalComponent

 */

 void CResourceArchiveImpl::ConstructL(RFs& aFs,const TDesC& aName)

 	{

 	RArray<TPtrC8> hiddenRscList;

 	CleanupClosePushL(hiddenRscList);

 	//Open the file and initialise the buffer pointer

 	TPtr8 bufferPtr(NULL,0,0);

 	OpenFileL(aFs,aName,bufferPtr);

 	//Now validate the header

 	ValidateHeaderL(bufferPtr);

 	//Process all the rsc entry

 	ProcessEntryL(bufferPtr,hiddenRscList);	

 	CleanupStack::PopAndDestroy();

 	}

 /** Function to get the string representation of a language code

 assume language code has max N digits currently equal to ELangMaximum

 note that the minimum suffix required is NN so TLang(0-9) needs to have a 0

 e.g s01...s09, s10, s100 etc

 @internalComponent

 */

 static void GetLangCodeStringRep(TLanguage lang,TDes& aStringRep)

 {

 	aStringRep.Zero();

 	//special case for 0-9 where you need the 0 appended, langcode min two digit

 	if (lang<10)

 		aStringRep.AppendNumFixedWidthUC(lang,EDecimal,2);

 	else

 		aStringRep.AppendFormat(_L("%d"),lang);

 }

 /**

 Open the file and initialise the aBufferPtr to point at the buffer

 @internalComponent

 */

 void CResourceArchiveImpl::OpenFileL(RFs& aFs,const TDesC& aName,TPtr8& aBufferPtr)

 	{

 	#ifdef __WINS__

 	TUint8* romAddress=NULL;

 	#else // ! __WINS__

 	TUint8* romAddress=aFs.IsFileInRom(aName);

 	#endif // ! __WINS__

 	RFile* const file=new(ELeave) RFile;

 	CleanupStack::PushL(TCleanupItem(CloseAndDeleteFile,file));

 	User::LeaveIfError(file->Open(aFs, aName, EFileStream | EFileRead | EFileShareReadersOnly));

 	TInt fileSize=0;

 	User::LeaveIfError(file->Size(fileSize));						

 	if (romAddress)

 		{	

 		aBufferPtr.Set(romAddress,fileSize,fileSize);

 		}

 	else

 		{

 		RChunk* rchunk = new(ELeave) RChunk;

 		CleanupStack::PushL(TCleanupItem(CloseAndDeleteChunk,rchunk));

 		TInt createRet = rchunk->CreateDisconnectedLocal(0, 0, fileSize);

 		TInt commitRet = rchunk->Commit(0, fileSize);

 		// Create a chunk to store the large file contents of which is closed and destroyed in destructor...

 		if(createRet==KErrNone && commitRet==KErrNone)

 			{

 			TUint8* chunkBase = (TUint8*)rchunk->Base();

 			TPtr8 tempBuffer(chunkBase, fileSize);

 			User::LeaveIfError(file->Read(0, tempBuffer, fileSize));

 			aBufferPtr.Set(tempBuffer);

 			iSpiChunkBufferArray.AppendL(rchunk);

 			CleanupStack::Pop(rchunk);

 			}

 		else	// Unable to create a chunk so use heap memory...

 			{

 			HBufC8* fileBuffer=HBufC8::NewMaxLC(fileSize);

 			aBufferPtr.Set(fileBuffer->Des());

 			User::LeaveIfError(file->Read(0,aBufferPtr,fileSize));

 			iSpiBufferArray.AppendL(fileBuffer);

 			CleanupStack::Pop(fileBuffer);

 			CleanupStack::PopAndDestroy(rchunk);

 			}

 		}

 	//can close the file now

 	CleanupStack::PopAndDestroy(file);

 #ifdef __BASPITEST__

 	iSpiFileNameArray.AppendL(aName);

 #endif		

 	}

 /**

 Validate the spi header in the file buffer

 On return it will update the bufferPtr to point to start of the first

 rsc entry

 @internalComponent

 */

 void CResourceArchiveImpl::ValidateHeaderL(TPtr8& aBufferPtr)

 	{

 	//Getting the 32 bytes header information. At the moment maybe we should just buffer 16 bytes

 	//of the header as the remaining 16 bytes are padding bytes

 	TUidType uidType=TCheckedUid(aBufferPtr.Left(16)).UidType();			

 	if (uidType[0]!=KSpiFileUid)

 		User::Leave(KErrCorrupt);

 	//now get the spi file type

 	TUid spiFileType=TUid::Uid(uidType[1].iUid);

 	if (iSpiFileType==KNullUid)

 		iSpiFileType=spiFileType;

 	//also check consistency with previous spi files

 	__ASSERT_DEBUG(iSpiFileType==spiFileType,::Panic(EBafPanicBadResourceFileFormat));							

 	//update the bufferPtr to point to start of first rsc entry

 	aBufferPtr.Set(aBufferPtr.MidTPtr(KSpiFirstRscOffset));	

 	}

 /**

 Process all the entry found in the buffer and update the internal rscList

 @internalComponent

 */

 void CResourceArchiveImpl::ProcessEntryL(TPtr8& aBufferPtr,RArray<TPtrC8>& aHiddenList)

 	{

 	//now traverse content of the spi file and build up the hidden list and the TRscEntry array

 	TRscEntry rscEntry;

 	while (aBufferPtr.Length()>0)

 		{

 		//length(first 4 bytes) and the actual rsc file size(second 4 bytes)

 		//Retrieving the rscfilename length

 		TUint32 rscFileNameLength=LittleEndianFourByteInteger(aBufferPtr,0);

 		TUint32 rscFileSize=LittleEndianFourByteInteger(aBufferPtr,4);

 		TUint32 paddingbyte=(4-((rscFileNameLength+rscFileSize)%4))%4;

 		__ASSERT_DEBUG((rscFileNameLength+rscFileSize+paddingbyte)%4==0,::Panic(EBafPanicFileSize));

 		//construct the TRscEntry				

 		rscEntry.iRscName.Set(aBufferPtr.Mid(8,rscFileNameLength));

 		rscEntry.iRscData.Set(aBufferPtr.Mid(8+rscFileNameLength,rscFileSize));

 #ifdef __BASPITEST__

 		rscEntry.iFileNamePtr.Set(iSpiFileNameArray[iSpiFileNameArray.Count()-1].Mid(0));

 #endif				

 		//update the buffer pointer

 		aBufferPtr.Set(aBufferPtr.MidTPtr(8+rscFileNameLength+rscFileSize+paddingbyte));

 		//process the TRscEntry

 		if (rscEntry.iRscData.Length()==0)

 			aHiddenList.AppendL(rscEntry.iRscName);

 		else

 			{

 			//if can find a matching resource name entry in the hidden list ignore this entry

 			TIdentityRelation<TPtrC8> identity(MatchDescriptor);

 			if (aHiddenList.Find(rscEntry.iRscName,identity)==KErrNotFound)

 				{

 				//note no duplicate entry, this implies the lastly mounted resource

 				//entry is preferred over earlier mounted resource entry.(REPLACING)

 				TInt ret=iRscList.InsertInOrder(rscEntry,EntryOrder);

 				if (ret!=KErrNone && ret!=KErrAlreadyExists)

 					User::Leave(ret);

 				}		

 			}

 		}//end while loop	

 	}

 /** ConstructL method that accepts a spi path and a matching pattern

 aPath here must end with \\ as well e.g. z:\\private\\10009d8f\\ 

 aPattern should be the spi file withou rom image id and extension

 @internalComponent

 */

 void CResourceArchiveImpl::ConstructL(RFs& aFs,const TDesC& aPath,const TDesC& aPattern)

 	{

 	//Get the downgradepath

 	RArray<TLanguage> downgradeList;

 	BaflUtils::GetDowngradePathL(aFs,User::Language(),downgradeList);

 	CleanupClosePushL(downgradeList);

 	//used to check if there is any matching pattern and leave with KErrNotFound if

 	//no matching spi

 	TInt spiDiscovered=0;

 	//sort out the language specific spi first

 	for (int i=0;i<=downgradeList.Count();i++)	

 		{

 		//list all the files in the directory that matches this language

 		TFileName matchPattern;

 		TBuf<5> langExtension;

 		if (i<downgradeList.Count())

 			GetLangCodeStringRep(downgradeList[i],langExtension);

 		else

 			{

 			//process the default spi lastly

 			langExtension.Append(_L("pi"));			

 			}

 		matchPattern.AppendFormat(_L("%S%S-*-*.s%S"),&aPath,&aPattern,&langExtension);

 		//Get all the spis that match the language pattern

 		CDir* spiList=NULL;

 		User::LeaveIfError(aFs.GetDir(matchPattern,KEntryAttReadOnly | KEntryAttHidden | KEntryAttSystem | KEntryAttArchive,ESortByName,spiList));

 		CleanupStack::PushL(spiList);

 		//the hidden list is only a temporary variable for each language

 		RArray<TPtrC8> hiddenRscList;

 		CleanupClosePushL(hiddenRscList);

 		//reverse processing

 		for (TInt i=spiList->Count()-1;i>=0;i--)

 			{

 			//reuse the matchPattern buffer to hold the full path of the spi file name

 			matchPattern.Zero();

 			matchPattern.Append(aPath);

 			matchPattern.Append((*spiList)[i].iName);

 			//Open the file and initialise the buffer pointer

 			TPtr8 bufferPtr(NULL,0,0);

 			OpenFileL(aFs,matchPattern,bufferPtr);

 			//Now validate the header

 			ValidateHeaderL(bufferPtr);

 			//Process all the rsc entry

 			ProcessEntryL(bufferPtr,hiddenRscList);

 			}//end for loop

 		spiDiscovered+=spiList->Count();

 		CleanupStack::PopAndDestroy(2);				//hiddenRscList and spiList

 		}//end for loop

 	//if no spi files are discovered at all leave with KErrNotFound

 	if (spiDiscovered==0)

 		User::Leave(KErrNotFound);

 	CleanupStack::PopAndDestroy(&downgradeList);

 	}

 /** Create the next CResourceFile that correponds to the next resource file

 in the resource archive(SPI) file

 @internalComponent

 */

 CResourceFile* CResourceArchiveImpl::NextL(HBufC*& aRscFileName)

 	{

 	//if end of list return nothing

 	if (iCurrentIndex==iRscList.Count())

 		return NULL;

 	//Construct the resource file name buffer

 	TRscEntry currentEntry=iRscList[iCurrentIndex];

 	HBufC* rscFileName=HBufC::NewLC(currentEntry.iRscName.Length());

 	TPtr modifiable(rscFileName->Des());

 	modifiable.Copy(currentEntry.iRscName);

 	//Construct the CResourceFile object	

 	CResourceFile* resourceFile=CResourceFile::NewL(currentEntry.iRscData);

 	CleanupStack::Pop(rscFileName);

 	//update the index

 	iCurrentIndex++;

 	aRscFileName=rscFileName;

 	return resourceFile;

 	}

 /** Reset the archive reader to start reading from the first resource

 @internalComponent 

 */

 void CResourceArchiveImpl::Reset()

 	{

 	iCurrentIndex=0;

 	}

 /** Return the type of the resource archive(SPI) file being read

 @internalComponent 

 */

 TUid CResourceArchiveImpl::Type()

 	{

 	return iSpiFileType;

 	}

 /** Function to look ahead whether next resource exists in the resource archive

 @internalComponent

 */

 TBool CResourceArchiveImpl::NextResourceExist() const

 	{

 	return (iCurrentIndex<iRscList.Count());

 	}

 /** Function used to retrieve a 4 bytes signed integer stored in Little Endian Format

 @internalComponent

 */

 TInt32 CResourceArchiveImpl::LittleEndianFourByteInteger(const TDesC8& aBuffer,TInt aIndexOfFirstByte) const

 	{

 	__ASSERT_DEBUG((aIndexOfFirstByte + 3) < aBuffer.Length(), ::Panic(EBafPanicBadIndex));

 	return aBuffer[aIndexOfFirstByte] | (aBuffer[aIndexOfFirstByte+1]<<8) | (aBuffer[aIndexOfFirstByte+2]<<16) | (aBuffer[aIndexOfFirstByte+3]<<24);

 	}