/*

* Copyright (c) 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 <memspy/engine/memspyenginehelperecom.h>

// System includes

#include <charconv.h>

// User includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyenginehelperfilesystem.h>

// Literal constants

_LIT8( KMemSpyEComXmlFileMimeType, "text/xml" );

_LIT8( KMemSpyXmlSpec_MasterSection, "memspy_ecom_sections" );

_LIT8( KMemSpyXmlSpec_ChildSectionCategory, "category" );

_LIT8( KMemSpyXmlSpec_ChildSectionCategory_Attribute_Name, "name" );

_LIT8( KMemSpyXmlSpec_ChildSectionInterface, "interface" );

_LIT8( KMemSpyXmlSpec_ChildSectionInterface_Name, "name" );

_LIT8( KMemSpyXmlSpec_ChildSectionInterface_Uid, "uid" );

_LIT8( KMemSpyXmlSpec_HexPrefix, "0x" );

CMemSpyEngineHelperECom::CMemSpyEngineHelperECom( CMemSpyEngine& aEngine )

:   iEngine( aEngine )

    {

    }

CMemSpyEngineHelperECom::~CMemSpyEngineHelperECom()

    {

    iCategories.ResetAndDestroy();

    iCategories.Close();

    //

    delete iParser;

    delete iConverter;

    //

    iEComSession.Close();

    REComSession::FinalClose();

    }

void CMemSpyEngineHelperECom::ConstructL()

    {

    TRAPD( err, ConstructInternalL() );

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructL() - error: %d", err );

    err = err;

    }

void CMemSpyEngineHelperECom::ConstructInternalL()

    {

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - START" );

    iEComSession = REComSession::OpenL();

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - creating parser..." );

	iParser = CParser::NewL( KMemSpyEComXmlFileMimeType, *this );

    // We only convert from UTF-8 to UTF-16

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - creating charconv object..." );

    iConverter = CCnvCharacterSetConverter::NewL();

    if  ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iEngine.FsSession() ) == CCnvCharacterSetConverter::ENotAvailable )

	    {

		User::Leave(KErrNotFound);

		}

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - reading xml..." );

    ConstructFromFileL();

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - END" );

    }

void CMemSpyEngineHelperECom::ConstructFromFileL()

    {

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - START" );

    // Locate the source file

    TRAPD( err, 

        HBufC* fileName = FindEComXmlFileNameLC();

        ParseL( *fileName );

        CleanupStack::PopAndDestroy( fileName );

        );

    err = err;

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - parse error: %d", err );

    delete iConverter;

    iConverter = NULL;

    // Build captions

    const TInt categoryCount = iCategories.Count();

    for( TInt i=0; i<categoryCount; i++ )

        {

        //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - building caption: %d", i );

        CMemSpyEngineEComCategory* cat = iCategories[ i ];

        cat->BuildCaptionL();

        }

    //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - END" );

    }

CMemSpyEngineHelperECom* CMemSpyEngineHelperECom::NewL( CMemSpyEngine& aEngine )

    {

    CMemSpyEngineHelperECom* self = new(ELeave) CMemSpyEngineHelperECom( aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

REComSession& CMemSpyEngineHelperECom::EComSession()

    {

    return iEComSession;

    }

EXPORT_C CMemSpyEngineEComCategory& CMemSpyEngineHelperECom::At( TInt aIndex )

    {

    return *iCategories[ aIndex ];

    }

EXPORT_C TInt CMemSpyEngineHelperECom::IndexOf( const CMemSpyEngineEComCategory& aEntry )

    {

    const TInt index = iCategories.Find( &aEntry );

    return index;

    }

EXPORT_C TInt CMemSpyEngineHelperECom::MdcaCount() const

    {

    return iCategories.Count();

    }

EXPORT_C TPtrC CMemSpyEngineHelperECom::MdcaPoint( TInt aIndex ) const

    {

    CMemSpyEngineEComCategory* category = iCategories[ aIndex ];

    return category->Caption();

    }

HBufC* CMemSpyEngineHelperECom::FindEComXmlFileNameLC()

    {

    RFs& fsSession = iEngine.FsSession();

    //

    TFileName* fileName = new(ELeave) TFileName();

    CleanupStack::PushL( fileName );

    //

    fsSession.PrivatePath( *fileName );

    //

    TFindFile findFile( fsSession );

    User::LeaveIfError( findFile.FindByPath( KMemSpyEComInterfaceIdFileName, fileName ) );

    //

    HBufC* ret = findFile.File().AllocL();

    CleanupStack::PopAndDestroy( fileName );

    CleanupStack::PushL( ret );

    return ret;

    }

void CMemSpyEngineHelperECom::ConvertL( const TDesC8& aInput, TDes16& aOutput )

    {

    const TInt error = iConverter->ConvertToUnicode( aOutput, aInput, iCharconvConverterState );

    User::LeaveIfError( error );

    }

void CMemSpyEngineHelperECom::ParseL( const TDesC& aFileName )

    {

	Xml::ParseL( *iParser, iEngine.FsSession(), aFileName );

    //

    const TInt error = iParserErrorCode;

    //RDebug::Printf( "CMemSpyEngineHelperECom::ParseL() - iParserErrorCode: %d", iParserErrorCode );

    iParserErrorCode = KErrNone;

    //

	User::LeaveIfError( error );

    }

void CMemSpyEngineHelperECom::OnChildSectionCategoryL( const RAttributeArray& aAttributes )

    {

    TBuf<128> name;

    TBool gotName = EFalse;

    //

    const TInt count = aAttributes.Count();

	for( TInt i=0; i<count; i++ )

		{

		const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() );

		const TPtrC8 value( aAttributes[ i ].Value().DesC() );

        //

		if  ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionCategory_Attribute_Name ) == 0 )

			{

            if  ( gotName )

                {

                User::LeaveIfError( KErrCorrupt );

                }

            else

                {

                ConvertL( value, name );

                gotName = ETrue;

                }

			}

        }

    //

    if  ( gotName )

        {

        // Make a new category

        //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionCategoryL() - creating category: %S"), &name );

        CMemSpyEngineEComCategory* category = CMemSpyEngineEComCategory::NewLC( *this, name );

        iCategories.AppendL( category );

        CleanupStack::Pop( category );

        //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionCategoryL() - created category: %S"), &name );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    }

void CMemSpyEngineHelperECom::OnChildSectionInterfaceL( const RAttributeArray& aAttributes )

    {

    TUid uid = KNullUid;

    TBuf<128> name;

    TBool gotName = EFalse;

    TBool gotUid = EFalse;

    //

    const TInt count = aAttributes.Count();

	for( TInt i=0; i<count; i++ )

		{

		const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() );

		const TPtrC8 value( aAttributes[ i ].Value().DesC() );

        //

		if  ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionInterface_Name ) == 0 )

			{

            if  ( gotName )

                {

                User::LeaveIfError( KErrCorrupt );

                }

            else

                {

                ConvertL( value, name );

                gotName = ETrue;

                }

			}

		else if ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionInterface_Uid ) == 0 )

			{

            if  ( gotUid )

                {

                User::LeaveIfError( KErrCorrupt );

                }

            else

                {

                if  ( value.Length() >= 8 )

                    {

                    TRadix radix = EDecimal;

                    TPtrC8 pValue( value );

                    //

                    if  ( value.Length() == 10 && value.Left( 2 ) == KMemSpyXmlSpec_HexPrefix )

                        {

                        pValue.Set( value.Mid( 2 ) );

                        radix = EHex;

                        }

                    //

                    TUint32 uidVal = 0;

                    TLex8 lexer( pValue );

                    const TInt err = lexer.Val( uidVal, radix );

                    User::LeaveIfError( err );

                    uid.iUid = uidVal;

                    gotUid = ETrue;

                    }

                }

			}

        }

    //

    const TInt catCount = iCategories.Count();

    if  ( gotName && gotUid && catCount > 0 )

        {

        //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionInterfaceL() - creating interface for %S [0x%08x]"), &name, uid.iUid );

        CMemSpyEngineEComCategory* category = iCategories[ catCount - 1 ];

        TRAPD( err, category->CreateInterfaceL( name, uid ) );

        err = err;

        //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionInterfaceL() - error: %d, for %S [0x%08x]"), err, &name, uid.iUid );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    }

void CMemSpyEngineHelperECom::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnEndDocumentL( TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnStartElementL( const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    //

	TInt err = KErrNone;

	const TPtrC8 name( aElement.LocalName().DesC() );

    //

    if  ( name.CompareF( KMemSpyXmlSpec_MasterSection ) == 0 )

		{

		iSeenMasterSection = ETrue;

		}

    else if ( iSeenMasterSection )

        {

        if  ( name.CompareF( KMemSpyXmlSpec_ChildSectionCategory ) == 0 )

            {

            OnChildSectionCategoryL( aAttributes );

            }

        else if ( name.CompareF( KMemSpyXmlSpec_ChildSectionInterface ) == 0 )

            {

            OnChildSectionInterfaceL( aAttributes );

            }

        }

    //

    User::LeaveIfError( err );

    }

void CMemSpyEngineHelperECom::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnStartPrefixMappingL( const RString& /*aPrefix*/, const RString& /*aUri*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnEndPrefixMappingL( const RString& /*aPrefix*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnSkippedEntityL( const RString& /*aName*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnProcessingInstructionL( const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

void CMemSpyEngineHelperECom::OnError( TInt aErrorCode )

    {

    iParserErrorCode = aErrorCode;

    }

TAny* CMemSpyEngineHelperECom::GetExtendedInterface( const TInt32 /*aUid*/ )

    {

    return NULL;

    }

CMemSpyEngineEComCategory::CMemSpyEngineEComCategory( CMemSpyEngineHelperECom& aHelper )

:   iHelper( aHelper )

    {

    }

CMemSpyEngineEComCategory::~CMemSpyEngineEComCategory()

    {

    delete iCaption;

    delete iName;

    iInterfaces.ResetAndDestroy();

    iInterfaces.Close();

    }

void CMemSpyEngineEComCategory::ConstructL( const TDesC& aName )

    {

    iName = aName.AllocL();

    iCaption = aName.AllocL(); // Replace later on

    }

CMemSpyEngineEComCategory* CMemSpyEngineEComCategory::NewLC( CMemSpyEngineHelperECom& aHelper, const TDesC& aName )

    {

    CMemSpyEngineEComCategory* self = new(ELeave) CMemSpyEngineEComCategory( aHelper );

    CleanupStack::PushL( self );

    self->ConstructL( aName );

    return self;

    }

EXPORT_C CMemSpyEngineEComInterface& CMemSpyEngineEComCategory::At( TInt aIndex )

    {

    return *iInterfaces[ aIndex ];

    }

EXPORT_C TInt CMemSpyEngineEComCategory::IndexOf( const CMemSpyEngineEComInterface& aEntry )

    {

    const TInt index = iInterfaces.Find( &aEntry );

    return index;

    }

EXPORT_C TInt CMemSpyEngineEComCategory::MdcaCount() const

    {

    return iInterfaces.Count();

    }

EXPORT_C TPtrC CMemSpyEngineEComCategory::MdcaPoint( TInt aIndex ) const

    {

    CMemSpyEngineEComInterface* iface = iInterfaces[ aIndex ];

    return iface->Caption();

    }

void CMemSpyEngineEComCategory::CreateInterfaceL( const TDesC& aName, TUid aUid )

    {

    CMemSpyEngineEComInterface* iface = CMemSpyEngineEComInterface::NewLC( *this, aName, aUid );

    iInterfaces.AppendL( iface );

    CleanupStack::Pop( iface );

    }

void CMemSpyEngineEComCategory::BuildCaptionL()

    {

    delete iCaption; 

    iCaption = NULL;

    _LIT( KCaptionFormat, "\t%S\t\t%d interface" );

    iCaption = HBufC::NewL( 256 );

    TPtr pCaption( iCaption->Des() );

    pCaption.Format( KCaptionFormat, iName, iInterfaces.Count() );

    if  ( iInterfaces.Count() > 1 )

        {

        pCaption.Append( 's' );

        }

    }