/*
* Copyright (c) 2004-2006 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: Data buffer loader for TTPHwDevice test executable
*
*/
// INCLUDE FILES
#include "ttsplugindataloader.h"
// CONSTANTS
_LIT( KDriveZ, "z:" );
// Assuming language data file name is something like SRSF_2_x[y|yz].bin
const TInt KBeginningOfLanguageId = 7;
#ifdef __SIND_AUTOCONF_LID
const TUint32 KTtpAutoConfLidPackageType = 1;
const TUint32 KTtpAutoConfLidPackageID = 1;
const TInt KLidBufGranularity = 1000;
#endif // __SIND_AUTOCONF_LID
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CTTSDataLoaderLoader::CTTSDataLoader
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CTTSDataLoader::CTTSDataLoader( RFs& aFs,
TFileName& aGeneralFileName,
TFileName& aPrefixOfTTPFileName,
TFileName& aPostfixOfTTPFileName,
TFileName& aTTSFilename,
TFileName& aPostfixOfTTSFilename ) :
iGeneralFileName( aGeneralFileName ),
iPrefixOfTTPFileName( aPrefixOfTTPFileName ),
iPostfixOfTTPFileName( aPostfixOfTTPFileName ),
iTTSFileName( aTTSFilename ),
iPostfixOfTTSFileName( aPostfixOfTTSFilename ),
iFs( aFs )
{
// Nothing
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::ConstructL()
{
// Nothing
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CTTSDataLoader* CTTSDataLoader::NewL( RFs& aFs,
TFileName& aGeneralFileName,
TFileName& aPrefixOfTTPFileName,
TFileName& aPostfixOfTTPFileName,
TFileName& aTTSFilename,
TFileName& aPostfixOfTTSFilename )
{
CTTSDataLoader* self = new ( ELeave ) CTTSDataLoader( aFs,
aGeneralFileName,
aPrefixOfTTPFileName,
aPostfixOfTTPFileName,
aTTSFilename,
aPostfixOfTTSFilename );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::~CTTSDataLoader
// Destructor.
// -----------------------------------------------------------------------------
//
CTTSDataLoader::~CTTSDataLoader()
{
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::LoadGeneralData
// Load general TTP data
// -----------------------------------------------------------------------------
//
HBufC8* CTTSDataLoader::LoadGeneralData( const TInt aPackageType,
const TInt aDataID,
TUint32 aStartPosition,
TUint32 aEndPosition )
{
TFileName fileName( iGeneralFileName );
fileName.AppendNum( aPackageType );
fileName.Append( _L( "_" ) );
fileName.AppendNum( aDataID );
fileName.Append( iPostfixOfTTPFileName );
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 &&
aDataID == KTtpAutoConfLidPackageID )
{
TRAPD( err, buffer = ConstructLidDataL() );
if ( !err )
{
return buffer;
}
}
#endif // __SIND_AUTOCONF_LID
TRAPD( error, buffer = DoLoadL( fileName, aStartPosition, aEndPosition ) );
if ( error == KErrNone )
{
return buffer;
}
else
{
return NULL;
}
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::LoadLanguageData
// Load TTP language data
// -----------------------------------------------------------------------------
//
HBufC8* CTTSDataLoader::LoadLanguageData( const TInt aPackageType,
TLanguage aLanguage,
TUint32 aStartPosition,
TUint32 aEndPosition )
{
TFileName fileName( iPrefixOfTTPFileName );
fileName.AppendNum( aPackageType );
fileName.Append( _L( "_" ) );
fileName.AppendNum( ( TInt ) aLanguage );
fileName.Append( iPostfixOfTTPFileName );
HBufC8* buffer( NULL );
TRAPD( error, buffer = DoLoadL( fileName, aStartPosition, aEndPosition ) );
if ( error == KErrNone )
{
return buffer;
}
else
{
return NULL;
}
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::LoadTtsData
// Load TTS general/language data
// -----------------------------------------------------------------------------
//
HBufC8* CTTSDataLoader::LoadTtsData( const TInt aPackageType,
const TInt aDataID,
TUint32 aStartPosition,
TUint32 aEndPosition )
{
TFileName fileName( iTTSFileName );
fileName.AppendNum( aPackageType );
fileName.Append( _L( "_" ) );
fileName.AppendNum( aDataID );
fileName.Append( iPostfixOfTTSFileName );
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 &&
aDataID == KTtpAutoConfLidPackageID )
{
TRAPD( err, buffer = ConstructLidDataL() );
if ( !err )
{
return buffer;
}
}
#endif // __SIND_AUTOCONF_LID
TRAPD( error, buffer = DoLoadL( fileName, aStartPosition, aEndPosition ) );
if ( error == KErrNone )
{
return buffer;
}
else
{
return NULL;
}
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::GetSupportedLanguagesL
// Fill aLanguages with supported language ids
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::GetSupportedLanguagesL( RArray<TLanguage>& aLanguages )
{
// Get pts languages
TFileName mask;
mask.Append( KDriveZ );
mask.Append( iTTSFileName );
mask.Append( _L( "2_*" ) );
DoGetSupportedLanguagesL( aLanguages, mask);
// Get ttp languages
RArray<TLanguage> ttpLanguages;
CleanupClosePushL( ttpLanguages );
mask.Zero();
mask.Append( KDriveZ );
mask.Append( iTTSFileName );
mask.Append( _L( "0_*" ) );
DoGetSupportedLanguagesL( ttpLanguages, mask);
// remove languages which are not supported in ttp
for ( TInt i(0); i < aLanguages.Count(); i++ )
{
if ( ttpLanguages.Find( aLanguages[i] ) == KErrNotFound )
{
aLanguages.Remove( i );
}
}
CleanupStack::PopAndDestroy( &ttpLanguages );
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::DoLoadL
// Loads the given file.
// -----------------------------------------------------------------------------
//
HBufC8* CTTSDataLoader::DoLoadL( TFileName& iFile,
TUint32 aStartPosition,
TUint32 aEndPosition )
{
TInt fileSize( 0 );
RFile dataFile;
TInt readLength;
TFileName completeFile;
completeFile.Append( KDriveZ );
completeFile.Append( iFile );
// Try to open file from Z drive
TInt err = dataFile.Open( iFs, completeFile, EFileRead );
if ( err != KErrNone )
{
return NULL;
}
// Try to resolve how much should be read
readLength = aEndPosition - aStartPosition;
if ( dataFile.Size( fileSize ) != KErrNone )
{
dataFile.Close();
return NULL;
}
if ( fileSize == 0 )
{
dataFile.Close();
return NULL;
}
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::NewL( readLength );
TPtr8 bufferPtr( fileBuffer->Des() );
err = dataFile.Read( bufferPtr );
dataFile.Close();
if ( err != KErrNone )
{
delete fileBuffer;
return NULL;
}
return fileBuffer;
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::DoGetSupportedLanguagesL
// Fill aLanguages with supported language ids
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::DoGetSupportedLanguagesL( RArray<TLanguage>& aLanguages,
TFileName& aMask )
{
CDir *directoryList( NULL );
TInt error = iFs.GetDir( aMask, KEntryAttDir, ESortByName, directoryList );
CleanupStack::PushL( directoryList );
if ( !error )
{
TInt count = directoryList->Count();
for ( TInt i( 0 ); i < count; i++ )
{
TPtrC tmp = (*directoryList)[i].iName;
TInt64 id;
TLex parser( tmp.Mid( KBeginningOfLanguageId ,
tmp.Find( _L(".") ) - KBeginningOfLanguageId ) );
User::LeaveIfError( parser.Val( id) );
TLanguage lang( (TLanguage)id );
if ( aLanguages.Find( lang ) == KErrNotFound )
{
aLanguages.AppendL( lang );
}
}
}
CleanupStack::PopAndDestroy( directoryList );
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::PackageName
// Construct filename for requested package
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::PackageName (TFileName &aFileName, TUint32 aPackageType, TUint32 aPackageID)
{
// Resolve the name of the file
// filename is <iPrefixOfTTPFileName>_<PackageType>_<aPackageID><iPostfixOfFileName>
aFileName.Copy( iPrefixOfTTPFileName ); // path/SRSF_
aFileName.AppendNumUC( aPackageType ); // path/SRSF_1
aFileName.Append( _L( "_" ) ); // path/SRSF_1_
aFileName.AppendNumUC( aPackageID ); // path/SRSF_1_326
aFileName.Append( iPostfixOfTTPFileName ); // path/SRSF_1_326.bin
}
#ifdef __SIND_AUTOCONF_LID
// -----------------------------------------------------------------------------
// CTTSDataLoader::AppendLoadL
// Load language package file to the end of buffer
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::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
}
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::LoadSysLangPackagesL
// Load LID language data to a buffer according to installed system languages
// -----------------------------------------------------------------------------
//
void CTTSDataLoader::SysLangPackagesToBufferL( CBufBase *aBuffer )
{
// Get installed languages
RArray<TLanguage> languages;
CleanupClosePushL( languages );
TFileName mask;
mask.Append( KDriveZ );
mask.Append( iTTSFileName );
mask.Append( _L( "1_*" ) );
DoGetSupportedLanguagesL( languages, mask);
// Loop over installed languages
for ( TInt i = 0 ; i < languages.Count(); i++ )
{
AppendLoadL(aBuffer, KTtpAutoConfLidPackageType, languages[i] );
}// next language
CleanupStack::PopAndDestroy( &languages );
}
// -----------------------------------------------------------------------------
// CTTSDataLoader::ConstructLidDataL
// Load LID language data to a buffer according to installed system languages
// -----------------------------------------------------------------------------
//
HBufC8* CTTSDataLoader::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
// End of File