/*

* Copyright (c) 2008 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:      XML SAX Parser for UPnP.

*

*/

// INCLUDE FILES

// system / xml parser

#include <xml/parser.h>

#include <xml/parserfeature.h>

#include <xml/matchdata.h>

// upnp stack api

#include <upnpstring.h>

// dlnasrv / xmlparser api

#include "upnpxmlparserlite.h"

#include "upnpobjectlite.h"

// dlnasrv / xmlparser internal

#include "upnpobjectstacklite.h"

_LIT( KComponentLogfile, "upnpxmlparser.txt");

#include "upnplog.h"

_LIT8( KXmlMimeType,    "text/xml"     );

_LIT8( KLIB2XML,        "libxml2" );

_LIT8( KContainer,      "container"    );

_LIT8( KItem,           "item"         );

_LIT8( KTitle,          "title"        );

_LIT8( KClass,          "class"        );

_LIT8( KId,             "id"           );

//_LIT8( KComma,          ":"            );

_LIT8( KDIDL,           "DIDL-Lite"    );

_LIT8( KDesc,           "desc"         );

_LIT8( KDlnaDoc,        "X_DLNADOC"    );

_LIT( KIndexContainer,  "1" );

_LIT( KIndexAudio,      "2" );

_LIT( KIndexVideo,      "3" );

_LIT( KIndexImage,      "4" );

_LIT( KIndexOther,      "5" );

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

// CUPnPXMLParserLite::CUPnPXMLParserLite()

// See upnpxmlparser.h

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

CUPnPXMLParserLite::CUPnPXMLParserLite()

    {

    }

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

// CUPnPXMLParserLite::ConstructL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::ConstructL()

    {

    __LOG( "CUPnPXMLParserLite::CostructL" );

    iStack = CUPnPObjectStackLite::NewL();

    }

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

// CUPnPXMLParserLite::NewL

// See upnpxmlparser.h

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

EXPORT_C CUPnPXMLParserLite* CUPnPXMLParserLite::NewL()

    {

    CUPnPXMLParserLite* self = CUPnPXMLParserLite::NewLC();

    CleanupStack::Pop( self );    

    return self;

    }

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

// CUPnPXMLParserLite::NewLC

// See upnpxmlparser.h

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

EXPORT_C CUPnPXMLParserLite* CUPnPXMLParserLite::NewLC()

    {   

    CUPnPXMLParserLite* self = new( ELeave ) CUPnPXMLParserLite();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUPnPXMLParserLite::~CUPnPXMLParserLite

// See upnpxmlparser.h

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

CUPnPXMLParserLite::~CUPnPXMLParserLite()

    {

    __LOG( "CUPnPXMLParserLite::~CUPnPXMLParserLite" );

    if ( iStack )

        {

        iStack->ResetAndDestroy();

        delete iStack;

        }

    delete iElementValue;

    delete iFormatString;

    delete iTitleBuf;

    }

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

// CUPnPXMLParserLite::ParseResultDataL

// See upnpxmlparser.h

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

EXPORT_C void CUPnPXMLParserLite::ParseResultDataL(

    RPointerArray<CUpnpObjectLite>& aResultArray, const TDesC8& aData,

    const TDesC& aFormatString )

    {

    __LOG( "CUPnPXMLParserLite::ParseResultDataL, begin" );

    delete iFormatString; iFormatString = NULL;

    if( aFormatString != KNullDesC )

        {

        iFormatString = aFormatString.AllocL();

        }

    if ( !aData.Length() )

        {

        User::Leave( KErrArgument );

        }

    iResultRoot = &aResultArray;

    // Create parser 

    CMatchData* matchData = CMatchData::NewLC();

    matchData->SetMimeTypeL( KXmlMimeType ); 

    matchData->SetVariantL( KLIB2XML ); 

    CParser* parser = CParser::NewLC( *matchData, *this ); 

    parser->EnableFeature( Xml::EReportNamespaceMapping );

    Xml::ParseL( *parser, aData );    

    CleanupStack::PopAndDestroy( parser );

    CleanupStack::PopAndDestroy( matchData );

    iResultRoot = NULL;           

    __LOG( "CUPnPXMLParserLite::ParseResultDataL, end" );

    }

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

// CUPnPXMLParserLite::OnStartDocumentL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnStartDocumentL( 

                                const RDocumentParameters& /*aDocParam*/, 

                                TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnEndDocumentL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnEndDocumentL( TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnStartElementL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnStartElementL( const RTagInfo& aElement, 

                                      const RAttributeArray& aAttributes,

                                      TInt aErrorCode )

    {

    __LOG1( "CUPnPXMLParserLite::OnStartElementL, error code: %d",

            aErrorCode );

    if ( aErrorCode != KErrNone )

        {

        return;

        }

    const TDesC8& desName = aElement.LocalName().DesC();

    const TDesC8& prefix = aElement.Prefix().DesC();

    // Delete content, since there may be some stuff between the elements

    // (comments, whitespace etc.)

    delete iElementValue; iElementValue = NULL;    

    if ( !desName.CompareF( KContainer ) ) // Container element

        {

        CUpnpObjectLite* tmpContainer = CUpnpObjectLite::NewL();

        CleanupStack::PushL( tmpContainer );

        SetAttributesL( *tmpContainer, aAttributes );

        //push into the stack, ownership is transferred                      

        iStack->PushL( tmpContainer ); 

        CleanupStack::Pop( tmpContainer );

        }

    else if ( !desName.CompareF( KItem ) ) // Item element

        {

        CUpnpObjectLite* tmpItem = CUpnpObjectLite::NewL();

        CleanupStack::PushL( tmpItem );

        SetAttributesL( *tmpItem, aAttributes );                      

        //push into the stack, ownership is transferred                      

        iStack->PushL( tmpItem );

        CleanupStack::Pop( tmpItem );

        }

    else if( !desName.CompareF( KTitle ) ) // Title element

        {

        // check that we have item or container. cause leave if not

        if ( iStack->Count() == 0)

            {

            User::Leave( KErrArgument );

            }

        // We should have an item or a container already!

        //__ASSERTD( iStack->Top(), __FILE__, __LINE__ );

        iTitle = ETrue;

        }

    else if( !desName.CompareF( KClass ) ) // Object class element

        {

        // check that we have item or container. cause leave if not

        if ( iStack->Count() == 0)

            {

            User::Leave( KErrArgument );

            }

        // We should have an item or a container already!

        //__ASSERTD( iStack->Top(), __FILE__, __LINE__ );

        iObjectClass = ETrue;

        }

    // Ignore DIDL-Lite, desc and X_DLNADOC -elements (DLNA req)

    else if( desName.Compare( KDIDL ) == KErrNone ||

             desName.Compare( KDesc ) == KErrNone ||

             desName.Compare( KDlnaDoc ) == KErrNone    

           )

        {

        // Ignore

        }

    else 

        {

        // check that we have item or container. cause leave if not

        if ( iStack->Count() == 0)

            {

            User::Leave( KErrArgument );

            }

        // Ignore rest of the elements

                }

    __LOG( "CUPnPXMLParserLite::OnStartElementL, end" );

    }

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

// CUPnPXMLParserLite::OnEndElementL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnEndElementL( const RTagInfo& aElement, 

                                    TInt aErrorCode )

    {

    __LOG( "CUPnPXMLParserLite::OnEndElementL(), begin" );

    if ( aErrorCode != KErrNone )

        {

        return;

        }

    const TDesC8& desName = aElement.LocalName().DesC();    

    if ( !desName.CompareF( KContainer ) || !desName.CompareF( KItem ) )

        {

        if( iTitleBuf )

            {

            CUpnpObjectLite* obj = iStack->Top();

            __ASSERTD( obj, __FILE__, __LINE__ );

            if( iFormatString )

                {

                HBufC* tempBuf = UpnpString::ToUnicodeL( *iTitleBuf );

                CleanupStack::PushL( tempBuf );

                HBufC* buf = HBufC::NewL( iFormatString->Length() +

                    tempBuf->Length() );

                CleanupStack::PushL( buf );

                buf->Des().Format( *iFormatString, tempBuf );

                obj->SetTitleL( buf );

                CleanupStack::Pop( buf );

                CleanupStack::PopAndDestroy( tempBuf );	

                }

            else

                {

                HBufC* buf = HBufC::NewL( iTitleBuf->Length() );

                CleanupStack::PushL( buf );

                buf->Des().Copy( *iTitleBuf );

                obj->SetTitleL( buf );

                CleanupStack::Pop( buf );

                }

            delete iTitleBuf; iTitleBuf = NULL;

            }

        iResultRoot->AppendL( iStack->Top() );

        iStack->Pop(); // Remove object from stack.

        }

    else if( KErrNone != desName.CompareF( KDIDL ))

        {        

        CUpnpObjectLite* obj = iStack->Top();

        __ASSERTD( obj, __FILE__, __LINE__ );

        if ( iElementValue )

            {

            if( !desName.CompareF( KTitle ) )

                {

                delete iTitleBuf; iTitleBuf = NULL;

                iTitleBuf = iElementValue;

                iElementValue = NULL;

                }

            else if( !desName.CompareF( KClass ) )

                {

                obj->SetObjectClass( *iElementValue );                

                iObjectClass = EFalse;

                if( iFormatString )

                    {

                    SetIconIndex( *obj );

                    }                

                }

            else

                {               

                }          

            }

        else

            {

            }    

        delete iElementValue; iElementValue = NULL;    

        }    

    __LOG( "CUPnPXMLParserLite::OnEndElementL(), end" );

    }

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

// CUPnPXMLParserLite::OnContentL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnContentL( const TDesC8& aBytes, TInt aErrorCode )

    {

    __LOG( "CUPnPXMLParserLite::OnContentL(), begin" );

    if ( !iStack->Count() || aErrorCode != KErrNone )

        {

        return;

        }

    if( iTitle || iObjectClass ) // We are only interested in title or

                                 // object class!

        {

        if( !iElementValue ) //if 1st time

            {

            iElementValue = HBufC8::NewL(aBytes.Length());

            iElementValue->Des().Copy(aBytes); 

            }

        else

            {

            HBufC8* previousValue = iElementValue;

            iElementValue = HBufC8::NewL( previousValue->Des().Length() +

                                          aBytes.Length() );

            iElementValue->Des().Append( *previousValue );

            iElementValue->Des().Append( aBytes );

            delete previousValue;

            }         

        }

    __LOG( "CUPnPXMLParserLite::OnContentL(), end" );

    }

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

// CUPnPXMLParserLite::OnStartPrefixMappingL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnStartPrefixMappingL( const RString& /*aPrefix*/, 

                                               const RString& /*aUri*/, 

                                               TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnEndPrefixMappingL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnEndPrefixMappingL( const RString& /*aPrefix*/, 

                                             TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnIgnorableWhiteSpaceL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/, 

                                                TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnSkippedEntityL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnSkippedEntityL( const RString& /*aName*/, 

                                          TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnProcessingInstructionL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnProcessingInstructionL( const TDesC8& /*aTarget*/, 

                                                  const TDesC8& /*aData*/, 

                                                  TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::OnError

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::OnError( TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLParserLite::GetExtendedInterface

// See upnpxmlparser.h

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

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

    {    

    // No implementation needed

    return NULL;

    }

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

// CUPnPXMLParserLite::SetAttributesL

// See upnpxmlparser.h

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

void CUPnPXMLParserLite::SetAttributesL( CUpnpObjectLite& aObject, 

    const RAttributeArray& aAttributes )

    {

    __LOG( "CUPnPXMLParserLite::SetAttributesL" );

    if ( iStack->Count() )

        {

        // Object has a parent.

        // Should not really happen

        __LOG( "Object has a parent!" );

        __PANICD(__FILE__, __LINE__);      

        }

    RAttribute attribute;

    TInt count = aAttributes.Count();

    for ( TInt i = 0 ; i < count; i++ ) // Read attributes.

        {

        attribute = aAttributes[ i ];

        const TDesC8& name = attribute.Attribute().LocalName().DesC();

        if( !name.CompareF( KId ) )

            {

            aObject.SetObjectIdL( attribute.Value().DesC() );

            }

        }

    __LOG( "CUPnPXMLParserLite::SetAttributesL - End" );

    }

void CUPnPXMLParserLite::SetIconIndex( const CUpnpObjectLite& aObject )

    {

    if( aObject.IsTypeOf( CUpnpObjectLite::EContainer ) )

        {

        iFormatString->Des().Replace( 0, 1, KIndexContainer );

        }

    else if( aObject.IsTypeOf( CUpnpObjectLite::EMusicItem ) )

        {

        iFormatString->Des().Replace( 0, 1, KIndexAudio );

        }

    else if( aObject.IsTypeOf( CUpnpObjectLite::EImageItem ) )