/*
* Copyright (c) 2005 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:  ?Description
*
*/


// INCLUDE FILES
#include "vcresource.h"
#include "rubydebug.h"
#include <defaultvoicecommands.rsg>
#include <barsc.h>
#include <barsread.h>
#include <bautils.h>
#include <data_caging_path_literals.hrh>
#include <numberconversion.h>

// CONSTANTS

// File name extension for EngineeringEnglish resource file
_LIT( KDefaultLanguageExtension, ".rsc" );

// Drives where resource file will be searched
const TBuf<2> KResourceDrives = _L("cz");


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

// -----------------------------------------------------------------------------
// CVcResource::CVcResource
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVcResource::CVcResource( RFs& aRFs )
 : iRFs( aRFs )
    {
    // Nothing
    }

// -----------------------------------------------------------------------------
// CVcResource::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CVcResource::ConstructL( const TDesC& aFileName )
    {
    RUBY_DEBUG_BLOCKL( "CVcResource::ConstructL" );
    
    ResolveResourceFileL( aFileName );
    }

// -----------------------------------------------------------------------------
// CVcResource::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVcResource* CVcResource::NewL( RFs& aRFs, const TDesC& aFileName )
    {
    CVcResource* self = new( ELeave ) CVcResource( aRFs );
    
    CleanupStack::PushL( self );
    self->ConstructL( aFileName );
    CleanupStack::Pop( self );
    
    return self;
    }

// -----------------------------------------------------------------------------
// CVcResource::~CVcResource
// Destructor.
// -----------------------------------------------------------------------------
//
CVcResource::~CVcResource()
    {
    iKeys.Close();
    iCommands.ResetAndDestroy();
    iCommands.Close();
    iIntegerKeys.Close();
    iIntegerValues.Close();
    }

// -----------------------------------------------------------------------------
// CVcResource::GetCommand
// Gets the localized string based on integer key
// -----------------------------------------------------------------------------
//
HBufC& CVcResource::GetCommandL( TInt aKey )
    {
    RUBY_DEBUG_BLOCKL( "CVcResource::GetCommandL(TInt)" );
    
    TInt index = iKeys.Find( aKey );
    User::LeaveIfError( index );

    return *iCommands[ index ];
    }

// -----------------------------------------------------------------------------
// CVcXmlParser::ReadValueFromLocFile
// Gets the localized string based on descriptor key 
// -----------------------------------------------------------------------------
//
HBufC& CVcResource::GetCommandL( const TDesC& aKey )
    {
    RUBY_DEBUG_BLOCKL( "CVcResource::GetCommandL(TDesC)" );
    
    TInt length( 0 );
    TInt result( 0 );
    TDigitType dt( EDigitTypeWestern );
    result = NumberConversion::ConvertFirstNumber( aKey, length, dt );

    if ( length == 0 )
        {
        User::Leave( KErrNotFound );
        }

    return GetCommandL( result );
    }

// -----------------------------------------------------------------------------
// CVcResource::GetValueL
// Gets the localized string based on integer key
// -----------------------------------------------------------------------------
//
TInt CVcResource::GetValueL( TInt aKey )
    {
    RUBY_DEBUG_BLOCKL( "CVcResource::GetValueL(TInt)" );
    
    TInt index = iIntegerKeys.Find( aKey );
    User::LeaveIfError( index );

    return iIntegerValues[ index ];
    }

// -----------------------------------------------------------------------------
// CVcXmlParser::ReadValueFromLocFile
// Gets the localized string based on descriptor key 
// -----------------------------------------------------------------------------
//
TInt CVcResource::GetValueL( const TDesC& aKey )
    {
    RUBY_DEBUG_BLOCKL( "CVcResource::GetValueL(TDesC)" );
    
    TInt length( 0 );
    TInt result( 0 );
    TDigitType dt( EDigitTypeWestern );
    result = NumberConversion::ConvertFirstNumber( aKey, length, dt );

    if ( length == 0 )
        {
        User::Leave( KErrNotFound );
        }

    return GetValueL( result );
    }


// -----------------------------------------------------------------------------
// CVcResource::ResolveResourceFileL
// Resolves the correct localized resource file name
// -----------------------------------------------------------------------------
//
void CVcResource::ResolveResourceFileL( const TDesC& aFileName )
    {
    RUBY_DEBUG_BLOCKL( "CVcXmlParser::ResolveResourceFileL" );
    
    // Resource file found/not found flag
    TBool found( EFalse );
    
    TFileName name;

    name.Append( 'a' ); // this will be replaced by real drive letter
    name.Append( ':' );
    name.Append( KDC_RESOURCE_FILES_DIR );
    name.Append( aFileName );
    name.Append( KDefaultLanguageExtension );
             
    TDriveList drivelist;
    User::LeaveIfError( iRFs.DriveList( drivelist ) ); 
    TInt drive( EDriveA );
    
    while ( !found && drive <= EDriveZ )
        {
        if ( drivelist[drive] ) 
            {
            TChar driveLetter; 
			User::LeaveIfError( iRFs.DriveToChar( drive, driveLetter ) );
            name[0] = driveLetter;
                    
            BaflUtils::NearestLanguageFile( iRFs, name );
         
            if ( BaflUtils::FileExists( iRFs, name ) )
                {
                // Read resource
                found = ETrue;
                ReadResourceFileL( iRFs, name );
                }
            }
        drive++;
        }
        
    }

// -----------------------------------------------------------------------------
// CVcResource::ReadResourceFileL
// Loads the resource file content
// -----------------------------------------------------------------------------
//
void CVcResource::ReadResourceFileL( RFs& aRfs, const TDesC& aFileName )
    {
    RUBY_DEBUG_BLOCKL( "CVcXmlParser::ReadResourceFileL" );
    
    RResourceFile resourceFile;

    resourceFile.OpenL( aRfs, aFileName );
    CleanupClosePushL( resourceFile );

	HBufC8* res = resourceFile.AllocReadLC( VOICECOMMANDS );

	TResourceReader reader;
	reader.SetBuffer( res );

    TInt index( 0 );
    TInt number( 0 );
    
    // The first WORD contains the number 
    // of structs within the resource
    number = reader.ReadInt16();

    for ( index = 0; index < number ; index++ )
        {
        TInt key = reader.ReadInt16();
        iKeys.Append( key );
        HBufC* command = reader.ReadHBufCL();
        iCommands.Append( command );
        }

	CleanupStack::PopAndDestroy( res );
	
	
	res = resourceFile.AllocReadLC( VCOMMANDINTEGERS );

	reader.SetBuffer( res );

    index = 0;
    number = 0;
    
    // The first WORD contains the number 
    // of structs within the resource
    number = reader.ReadInt16();

    for ( index = 0; index < number ; index++ )
        {
        iIntegerKeys.Append( reader.ReadInt16() );
        iIntegerValues.Append( reader.ReadInt16() );
        }

	CleanupStack::PopAndDestroy( res );
	CleanupStack::PopAndDestroy( &resourceFile );
    }
    
// End of File