/*

* Copyright (c) 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:  

*

*/

#include "catalogsutils.h"

#include <utf.h>

#include <e32base.h>

#include <f32file.h>

#include <bautils.h>

#include <s32strm.h>

#include <s32mem.h>

#include <sysutil.h>

#include <pathinfo.h> 

#ifndef __S60_32__

#include <platform/mw/languages.hrh>

#endif

#include "catalogsconstants.h"

#include "catalogsbasemessage.h"

#include "catalogsdebug.h"

// Maximum length of a signed 16 bit integer when converted to a string

const TInt K16BitIntAsDescLength = 6;

// Maximum length of a signed 32 bit integer when converted to a string

const TInt K32BitIntAsDescLength = 11;

_LIT( KInitialSearchDrive, "Y:" );

void TCatalogsVersion::ConvertL( TCatalogsVersion& aTarget, const TDesC& aVersion )

    {

    TUint16 major = 0;

    TUint16 minor = 0;

    TUint32 build = 0;

    if ( aVersion.Length() ) 

        {        

        DesToVersionL( aVersion, major, minor, build );

        }

    aTarget = TCatalogsVersion( major, minor, build );        

    }

HBufC* TCatalogsVersion::ConvertLC( const TCatalogsVersion& aSource )

    {

    DLTRACEIN(("input: %u.%u.%u", 

        aSource.iMajor,

        aSource.iMinor,

        aSource.iBuild ));

    _LIT( KFormatString, "%u.%u.%u");

    HBufC* target = HBufC::NewLC( 

        // Length of major + minor

        2 * K16BitIntAsDescLength +

        // length of build

        K32BitIntAsDescLength + 

        // separators: '.'

        2 );

    TPtr ptr( target->Des() );

    ptr.Format( 

        KFormatString, 

        aSource.iMajor, 

        aSource.iMinor, 

        aSource.iBuild );

    DLTRACEOUT(( _L("Output: %S"), target));    

    return target;

    }

TCatalogsVersion::TCatalogsVersion()

    {

    iMajor = 0;

    iMinor = 0;

    iBuild = 0;

    }

TCatalogsVersion::TCatalogsVersion( TUint16 aMajor,

                                    TUint16 aMinor,

                                    TUint32 aBuild )

    {

    iMajor = aMajor;

    iMinor = aMinor;

    iBuild = aBuild;

    }

TBool TCatalogsVersion::operator==( const TCatalogsVersion& aVersion ) const

    {

    return iMajor == aVersion.iMajor && 

           iMinor == aVersion.iMinor &&

           iBuild == aVersion.iBuild;

    }

TBool TCatalogsVersion::operator>( const TCatalogsVersion& aVersion ) const

    {

    return ( iMajor > aVersion.iMajor ) || 

        ( iMajor == aVersion.iMajor && ( iMinor > aVersion.iMinor ||

        ( iMinor == aVersion.iMinor && iBuild > aVersion.iBuild ) ) );

    }

TBool TCatalogsVersion::operator>=( const TCatalogsVersion& aVersion ) const

    {

    return operator==( aVersion ) || operator>( aVersion );

    }

#ifndef NCD_STORAGE_TESTING

// ---------------------------------------------------------------------------

// RCatalogsMessageReader

// ---------------------------------------------------------------------------

//    

RCatalogsMessageReader::RCatalogsMessageReader()

    {

    }

void RCatalogsMessageReader::OpenL( MCatalogsBaseMessage& aMessage )

    {

    iBuf.CreateL( aMessage.InputLength() );    

    User::LeaveIfError( aMessage.ReadInput( iBuf ) );

    iStream.Open( iBuf );

    }

void RCatalogsMessageReader::OpenLC( MCatalogsBaseMessage& aMessage )

    {

    CleanupClosePushL( *this );

    OpenL( aMessage );    

    }

void RCatalogsMessageReader::Close()

    {

    iStream.Close();

    iBuf.Close();        

    }

RCatalogsMessageReader::~RCatalogsMessageReader()

    {

    }

#endif

// ---------------------------------------------------------------------------

// RCatalogsBufferWriter

// ---------------------------------------------------------------------------

//    

RCatalogsBufferWriter::RCatalogsBufferWriter() : iBuf( NULL )

    {

    }

void RCatalogsBufferWriter::OpenL()

    {    

    iBuf = CBufFlat::NewL( KBufExpandSize );    

    iStream.Open( *iBuf );

    }

void RCatalogsBufferWriter::OpenLC()

    {

    CleanupClosePushL( *this );

    OpenL();

    }

void RCatalogsBufferWriter::Close()

    {

    iStream.Close();

    delete iBuf;

    iBuf = NULL;

    }

RCatalogsBufferWriter::~RCatalogsBufferWriter()

    {

    }

// ---------------------------------------------------------------------------

// Utility functions

// ---------------------------------------------------------------------------

//    

void AssignDesL( HBufC8*& aDes, const TDesC8& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = aSource.AllocL();

    }

void AssignDesL( HBufC16*& aDes, const TDesC16& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = aSource.AllocL();

    }

void AssignDesL( HBufC16*& aDes, const TDesC8& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = ConvertUtf8ToUnicodeL( aSource );

    }

HBufC16* ConvertUtf8ToUnicodeL( const TDesC8& aUtfText )

    {

    HBufC16* buffer = HBufC16::NewLC( aUtfText.Length() );

    TPtr ptr( buffer->Des() );

    User::LeaveIfError( 

        CnvUtfConverter::ConvertToUnicodeFromUtf8( ptr,

                                                   aUtfText ) );

    CleanupStack::Pop( buffer );

    return buffer;

    }

HBufC8* ConvertUnicodeToUtf8L( const TDesC16& aUnicodeText )

    {

    const TInt KConvertBufferSize = 32;

    // Place converted data here, initial size double the conversion buffer.

    HBufC8* convertedData = HBufC8::NewL( KConvertBufferSize * 2 );

    CleanupStack::PushL( convertedData );

    TPtr8 destination( convertedData->Des() );

    // Create a small output buffer

    TBuf8<KConvertBufferSize> outputBuffer;

    // Create a buffer for the unconverted text - initialised with the 

    // input text

    TPtrC16 remainderOfUnicodeText( aUnicodeText );

    for ( ;; ) // conversion loop

        {

        // Start conversion. When the output buffer is full, return the 

        // number of characters that were not converted

        const TInt returnValue

            = CnvUtfConverter::ConvertFromUnicodeToUtf8( outputBuffer, 

            remainderOfUnicodeText );

        // check to see that the descriptor isn’t corrupt - leave if it is

        if ( returnValue == CnvUtfConverter::EErrorIllFormedInput )

            {            

            User::Leave( KErrCorrupt );

            }

        else if ( returnValue < 0 ) // future-proof against "TError" expanding

            {            

            User::Leave( KErrGeneral );

            }

        // Do something here to store the contents of the output buffer.

        if ( destination.Length() + outputBuffer.Length() >= 

             destination.MaxLength() )

            {

            HBufC8* newBuffer = convertedData->ReAllocL(

                ( destination.MaxLength() + outputBuffer.Length() ) * 2 );

            CleanupStack::Pop( convertedData );

            convertedData = newBuffer;

            CleanupStack::PushL( convertedData );

            destination.Set( convertedData->Des() );

            }

        destination.Append( outputBuffer );

        outputBuffer.Zero();

        // Finish conversion if there are no unconverted characters 

        // in the remainder buffer

        if ( returnValue == 0 ) 

            {            

            break; 

            }

        // Remove the converted source text from the remainder buffer.

        // The remainder buffer is then fed back into loop

        remainderOfUnicodeText.Set( 

            remainderOfUnicodeText.Right( returnValue) );

        }

    CleanupStack::Pop( convertedData );

    return convertedData;

    }

HBufC8* Des16ToDes8LC( const TDesC16& aDes )

    {

    HBufC8* buffer = HBufC8::NewLC( aDes.Length() );

    buffer->Des().Copy( aDes );

    return buffer;

    }

HBufC8* Des16ToDes8L( const TDesC16& aDes )

    {

    HBufC8* t = Des16ToDes8LC( aDes );

    CleanupStack::Pop();

    return t;

    }

HBufC16* Des8ToDes16LC( const TDesC8& aDes )

    {

    HBufC16* buffer = HBufC16::NewLC( aDes.Length() );

    buffer->Des().Copy( aDes );

    return buffer;

    }

HBufC16* Des8ToDes16L( const TDesC8& aDes )

    {

    HBufC16* t = Des8ToDes16LC( aDes );

    CleanupStack::Pop();

    return t;

    }    

TInt DesDecToIntL( const TDesC& aDes )

    {

    TLex lex( aDes );

    TInt value;

    User::LeaveIfError( lex.Val( value ) );

    return value;

    }

TInt DesDecToInt( const TDesC8& aDes, TInt& aValue )

    {

    TLex8 lex( aDes );

    return lex.Val( aValue );

    }

TInt DesDecToInt( const TDesC16& aDes, TInt& aValue )

    {

    TLex16 lex( aDes );

    return lex.Val( aValue );

    }

TInt DesHexToIntL( const TDesC& aDes )

    {

    TLex lex( aDes );

    TInt position = aDes.LocateF( 'x' );

    if ( position != KErrNotFound ) 

        {

        // Hex format is of type '0xABC' or 'xABC'

        // Skip over the x-part.

        lex.Assign( aDes.Mid( position+1 ) );

        }

    TUint value;

    User::LeaveIfError( lex.Val( value, EHex ) );

    return value;

    }

TInt Des8ToInt( const TDesC8& aDes )

    {

    return *(( TInt* )aDes.Ptr());

    }

TUint Des8ToUint( const TDesC8& aDes )

    {

    return *(( TUint* )aDes.Ptr());

    }

HBufC8* IntToDes8LC( TInt aInt )

    {

    HBufC8* buffer = HBufC8::NewMaxLC( sizeof( aInt ) );

    TPtr8 ptr( buffer->Des() );

    *(( TInt* )ptr.Ptr()) = aInt;

    return buffer;

    }

HBufC8* IntToDes8L( TInt aInt )

    {

    HBufC8* t = IntToDes8LC( aInt );

    CleanupStack::Pop();

    return t;

    }

HBufC8* UintToDes8LC( TUint aUint )

    {

    HBufC8* buffer = HBufC8::NewMaxLC( sizeof( aUint ) );

    TPtr8 ptr( buffer->Des() );

    *(( TUint* )ptr.Ptr()) = aUint;

    return buffer;

    }

HBufC8* UintToDes8L( TUint aUint )

    {

    HBufC8* t = UintToDes8LC( aUint );

    CleanupStack::Pop();

    return t;

    }

// ---------------------------------------------------------------------------

// ExternalizeDesL

// ---------------------------------------------------------------------------

//    

void ExternalizeDesL( const TDesC16& aDes, RWriteStream& aStream )

    {

    aStream.WriteInt32L( aDes.Length() );

    aStream.WriteL( aDes );

    }

// ---------------------------------------------------------------------------

// InternalizeDesL

// ---------------------------------------------------------------------------

//    

TInt InternalizeDesL( HBufC16*& aDes, RReadStream& aStream )

    {

    //DLTRACEIN(("16bit"));

    TInt length = aStream.ReadInt32L();

    //DLTRACE(("length: %i", length));

    if ( length > 0 ) 

        {

        HBufC* target = HBufC::NewLC( length );

        TPtr ptr( target->Des() );

        aStream.ReadL( ptr, length );

        delete aDes;

        aDes = target;

        CleanupStack::Pop( target );

        }

    else

        {

        delete aDes;

        aDes = KNullDesC16().AllocL();

        }

    //DLTRACEOUT((""));

    return length;

    }

// ---------------------------------------------------------------------------

// ExternalizeDesL

// ---------------------------------------------------------------------------

//    

void ExternalizeDesL( const TDesC8& aDes, RWriteStream& aStream )

    {

    aStream.WriteInt32L( aDes.Length() );

    aStream.WriteL( aDes );

    }

// ---------------------------------------------------------------------------

// InternalizeDesL

// ---------------------------------------------------------------------------

//    

TInt InternalizeDesL( HBufC8*& aDes, RReadStream& aStream )

    {

    //DLTRACEIN(("8bit"));

    TInt length = aStream.ReadInt32L();

    //DLTRACE(("length: %i", length));

    if ( length > 0 ) 

        {

        HBufC8* target = HBufC8::NewLC( length );

        TPtr8 ptr( target->Des() );

        aStream.ReadL( ptr, length );

        delete aDes;

        aDes = target;

        CleanupStack::Pop( target );

        }

    else

        {

        delete aDes;

        aDes = KNullDesC8().AllocL();

        }

    //DLTRACEOUT((""));

    return length;

    }

HBufC* FindEngineFileL( RFs& aFs, const TDesC& aFilename )

    {

    DLTRACEIN(( _L("Find: %S"), &aFilename ));

    // Get engine's private path

    RBuf target;

    CleanupClosePushL( target );

    target.CreateL( KMaxPath );

    User::LeaveIfError( aFs.PrivatePath( target ) );

    // Set Y: as the first drive to be searched instead of session

    // path's drive which is C:       

    target.Insert( 0, KInitialSearchDrive );

    DLTRACE(( _L("Path to search from: %S"), &target ));

    // Find the file

    TFindFile find( aFs );

    User::LeaveIfError( find.FindByDir( aFilename, target ) );

    CleanupStack::PopAndDestroy( &target );    

    DLTRACEOUT(( _L("Found the file from: %S"), 

        &find.File() ));

    return find.File().AllocL();    

    }

TBool IsRomDriveL( RFs& aFs, TChar aDriveChar )

    {