/*
* Copyright (c) 2004 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:  Language package data file loader 
*
*/


// INCLUDE FILES
#include "asrplugindataloader.h"
#include "sysconfigprovider.h"


#ifdef __SIND_AUTOCONF_LID
#include <syslangutil.h>
/* MSysConfigProvider is a wrapper for get syslangutil. This makes it easier to test without */
/* dependency to the actual language configuration in the emulator environment. The test  */
/* class implements this interface. */
class TDefaultConfig : public MSysConfigProvider {
public:
	TDefaultConfig() {};
	~TDefaultConfig() {};
	TInt GetInstalledLanguages( CArrayFixFlat<TInt>*& aLanguages, RFs* aFileServerSession = NULL ) 
	{
		return SysLangUtil::GetInstalledLanguages(aLanguages, aFileServerSession);		
	};
};
#endif  // __SIND_AUTOCONF_LID

// Local constants

_LIT( KZDriveLetter, "z" ); 
 

#ifdef __SIND_AUTOCONF_LID
const TUint32 KTtpAutoConfLidPackageType = 1;
const TUint32 KTtpAutoConfLidPackageID   = 1;
const TInt KLidBufGranularity = 1000;
#endif  // __SIND_AUTOCONF_LID


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CDataLoaderLoader::CDataLoader
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CDataLoader::CDataLoader() 
    {
    // Nothing
    }

// -----------------------------------------------------------------------------
// CDataLoader::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CDataLoader::ConstructL( const TDesC& aPrefixOfFileName,
							  const TDesC& aSeparator,                                     
                              const TDesC& aPostfixOfFileName,
                              MSysConfigProvider *aProvider )
    {
    iPrefixOfFileName = HBufC::NewL( aPrefixOfFileName.Length() );
    (*iPrefixOfFileName) = aPrefixOfFileName;
    iSeparator = HBufC::NewL( aSeparator.Length() );
    (*iSeparator) = aSeparator;
    iPostfixOfFileName = HBufC::NewL( aPostfixOfFileName.Length() );
    (*iPostfixOfFileName) = aPostfixOfFileName;
    
	iProvider = aProvider;

    // Open file session
    User::LeaveIfError( iFs.Connect() );
    }

// -----------------------------------------------------------------------------
// CDataLoader::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CDataLoader* CDataLoader::NewL( const TDesC& aPrefixOfFileName,
								const TDesC& aSeparator,                                     
                                const TDesC& aPostfixOfFileName,
                                MSysConfigProvider *aProvider )
    {
    CDataLoader* self = new ( ELeave ) CDataLoader();
    
    CleanupStack::PushL( self );
    self->ConstructL( aPrefixOfFileName,
					  aSeparator,                                     
                      aPostfixOfFileName,
                      aProvider);
    CleanupStack::Pop( self );
    
    return self;
    }

// -----------------------------------------------------------------------------
// CDataLoader::~CDataLoader
// Destructor.
// -----------------------------------------------------------------------------
//
CDataLoader::~CDataLoader()
    {
    delete iPrefixOfFileName,
	delete iSeparator,                                     
    delete iPostfixOfFileName;    
    
    iFs.Close();
    }

// -----------------------------------------------------------------------------
// CDataLoader::PackageName
// Construct filename for requested package
// -----------------------------------------------------------------------------
//	
void CDataLoader::PackageName (TFileName &aFileName, TUint32 aPackageType, TUint32 aPackageID) 
{
	// Resolve the name of the file
	// filename is <iPrefixOfFileName>_<PackageType>_<aPackageID><iPostfixOfFileName>

	aFileName.Copy( iPrefixOfFileName->Des() );          //  path/SRSF_
	aFileName.AppendNumUC( aPackageType );               //  path/SRSF_1
	aFileName.Append( iSeparator->Des() );               //  path/SRSF_1_
	aFileName.AppendNumUC( aPackageID );                 //  path/SRSF_1_326
	aFileName.Append( iPostfixOfFileName->Des() );       //  path/SRSF_1_326.bin
}

#ifdef __SIND_AUTOCONF_LID
// -----------------------------------------------------------------------------
// CDataLoader::AppendLoadL
// Load language package file to the end of buffer
// -----------------------------------------------------------------------------
//	
void CDataLoader::AppendLoadL( CBufBase *aBuffer,
								TUint32 aPackageType, 
								TUint32 aPackageID ) 
{
	// Resolve filename
	TFileName fileName;
	PackageName (fileName, aPackageType, aPackageID);

	// Load data
	HBufC8* buffer = NULL;
	
	TRAPD( err, buffer = DoLoadL( fileName, 0, KMaxTUint32 ));  // IMPLICIT: LID packages are loaded completely
 	if( err == KErrNone && buffer ) 
 	{
		CleanupStack::PushL( buffer );                    // ResizeL may leave below

		TInt prevSize = aBuffer->Size();                  // size before resize
		TInt newSize  = aBuffer->Size() + buffer->Size(); // new size for lid data buffer

		aBuffer->ResizeL( newSize );                      // resize lid data buffer
		aBuffer->Write( prevSize, *buffer );              // append data from read buffer

		CleanupStack::PopAndDestroy(buffer);              // buffer copied -> free
	}
}



// -----------------------------------------------------------------------------
// CDataLoader::LoadSysLangPackagesL
// Load LID language data to a buffer according to installed system languages
// -----------------------------------------------------------------------------
//	
void CDataLoader::SysLangPackagesToBufferL( CBufBase *aBuffer ) 
{        
	MSysConfigProvider *config = iProvider;
	TDefaultConfig defaultProvider;
	if (!config) config = &defaultProvider;

	// Get installed languages
	CArrayFixFlat<TInt>* languages( NULL );

	//User::LeaveIfError (SysLangUtil::GetInstalledLanguages(languages, &iFs));
	User::LeaveIfError (config->GetInstalledLanguages(languages, &iFs));
	CleanupStack::PushL( languages ) ;

	// Loop over installed languages
	for ( TInt i = 0 ; i < languages->Count(); i++ )
	{
		AppendLoadL(aBuffer, KTtpAutoConfLidPackageType, languages->At(i));
	}// next language
	
	CleanupStack::PopAndDestroy( languages );
}

// -----------------------------------------------------------------------------
// CDataLoader::ConstructLidDataL
// Load LID language data to a buffer according to installed system languages
// -----------------------------------------------------------------------------
//	
HBufC8* CDataLoader::ConstructLidDataL()
{
	CBufBase* lidDataBuffer = CBufSeg::NewL( KLidBufGranularity ) ; // accumulates the binary data from lid model files
	CleanupStack::PushL( lidDataBuffer ) ;

	SysLangPackagesToBufferL (lidDataBuffer);

	// Prepare returnable data
	HBufC8* dataBuffer = NULL;
	
	if( lidDataBuffer->Size() > 0 ) 
	{
		// If any data was loaded, create a buffer for it
		dataBuffer = HBufC8::NewL( lidDataBuffer->Size() );     // create a returnable buffer
		TPtr8 dataBufferPtr = dataBuffer->Des();                        // get a modifiable pointer to it
		lidDataBuffer->Read( 0, dataBufferPtr, lidDataBuffer->Size() ); // put the lid data into it
	}

	CleanupStack::PopAndDestroy( lidDataBuffer ) ;  

	return dataBuffer;
}
#endif  // __SIND_AUTOCONF_LID


// -----------------------------------------------------------------------------
// CDataLoader::LoadData
// Load language package file. It resolves the name of the language package
// -----------------------------------------------------------------------------
//	
HBufC8* CDataLoader::LoadData( TUint32 aPackageType, 
								TUint32 aPackageID,
								TUint32 aStartPosition,
								TUint32 aEndPosition ) {

	TInt err;
	HBufC8* buffer = NULL;

#ifdef __SIND_AUTOCONF_LID
	// If LID data is requested, construct it from installed LID binary files
	// Otherwise run normal data loading

	if( aPackageType == KTtpAutoConfLidPackageType &&
		aPackageID   == KTtpAutoConfLidPackageID )
	{
		TRAP( err, buffer = ConstructLidDataL() );
	}
#endif  // __SIND_AUTOCONF_LID

	if (!buffer)	{
		TFileName fileName;
		PackageName (fileName, aPackageType, aPackageID);
	
		// Load data    
		TRAP( err, buffer = DoLoadL( fileName, aStartPosition, aEndPosition ) );
	}

	if ( err == KErrNone )
	{
		return buffer;
  }
	else
	{
		return NULL;
	}    
}
                                         


// -----------------------------------------------------------------------------
// CDataLoader::DoLoadL
// Actual file loading function
// -----------------------------------------------------------------------------
//	
HBufC8* CDataLoader::DoLoadL( TFileName& aFileName,
                              TUint32 aStartPosition, 
                              TUint32 aEndPosition )
    {
    TInt fileSize( 0 );
    RFile dataFile;
    TInt readLength;

    // Open file	
    TInt err = dataFile.Open( iFs, aFileName, EFileRead);
	 
		if ( err != KErrNone )	 
		{		
			aFileName.Replace(0,1,KZDriveLetter); // "z:\"
			TInt err = dataFile.Open( iFs, aFileName, EFileRead);		 
			if ( err != KErrNone )
          {
    			return NULL;
          }
		}

	CleanupClosePushL( dataFile );
    // Try to resolve how much should be read
    readLength = aEndPosition - aStartPosition;
    User::LeaveIfError( dataFile.Size( fileSize ) );

    if ( aEndPosition != KMaxTUint32 )
        {
        // Cannot read more than filesize
        if ( ( readLength > fileSize ) || ( readLength < 0 ) )
            {
            readLength = fileSize;
            }
        }
    else
        {
        readLength = fileSize;
        }
    
    // Seek the starting point
    // Casting needed to convert from uint to int which is needed by Seek()
    TInt startPosition = ( TInt ) aStartPosition;
    dataFile.Seek( ESeekStart, startPosition );

    // Reserve enough memory for the data
    HBufC8* fileBuffer = HBufC8::NewLC( readLength );
    TPtr8 bufferPtr( fileBuffer->Des() );
    
    User::LeaveIfError( dataFile.Read( bufferPtr ) );

    CleanupStack::Pop( fileBuffer );
    CleanupStack::PopAndDestroy( &dataFile );
    return fileBuffer;
    }

// End of File