/*

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

*

*/

#include <xml/parser.h>

#include <xml/parserfeature.h>

#include <upnpstring.h>

#include <xml/matchdata.h>

#include "upnpxmleventparser.h"

#include "upnpavtevent.h"

_LIT( KComponentLogfile, "upnpxmlparser.txt");

#include "upnplog.h"

_LIT8( KXmlMimeType,    "text/xml"     );

_LIT8( KLIB2XML,        "libxml2" );

_LIT8( KEvent,          "Event"         );

_LIT8( KInstanceID,     "InstanceID"    );

_LIT8( KVolume,         "Volume"        );

_LIT8( KMute,           "Mute"          );

_LIT8( KDIDL,           "DIDL-Lite"     );

_LIT8( KDesc,           "desc"          );

_LIT8( KDlnaDoc,        "X_DLNADOC"     );

_LIT8( KVal,            "val"           );

_LIT8( KChannel,        "channel"       );

_LIT8( KMaster,         "Master"       );

_LIT8( KTransportState, "TransportState" );

_LIT8( KTransportURI,   "AVTransportURI" );

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

// CUPnPXMLEventParser::CUPnPXMLEventParser()

// See upnpxmlparser.h

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

CUPnPXMLEventParser::CUPnPXMLEventParser()

    {

    // No implementation required

    }

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

// CUPnPXMLEventParser::ConstructL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::ConstructL()

    {

    __LOG( "CUPnPXMLEventParser::CostructL" );

    iAvtEvent = CUPnPAVTEvent::NewL();

    iAvtResultEvent = CUPnPAVTEvent::NewL();

    }

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

// CUPnPXMLEventParser::NewL

// See upnpxmlparser.h

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

EXPORT_C CUPnPXMLEventParser* CUPnPXMLEventParser::NewL()

    {

    __LOG( "CUPnPXMLEventParser::NewL" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);    

    return self;

    }

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

// CUPnPXMLEventParser::~CUPnPXMLEventParser

// See upnpxmlparser.h

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

CUPnPXMLEventParser::~CUPnPXMLEventParser()

    {

    __LOG( "CUPnPXMLEventParser::~CUPnPXMLEventParser" );

    delete iAvtEvent;

    delete iAvtResultEvent;

    }

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

// CUPnPXMLEventParser::ParseRcEventDataL

// See upnpxmlparser.h

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

EXPORT_C CUPnPAVTEvent* CUPnPXMLEventParser::ParseRcEventDataL(

    const TDesC8& aData, const TInt aInstanceId )

    {

    __LOG( "CUPnPXMLEventParser::ParseRcEventDataL, begin" );

    if ( !aData.Length() )

        {

        User::Leave( KErrArgument );

        }

    Reset();

    ResetResult();

    iSessionInstanceID = aInstanceId;

    // 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 );

    if( iAvtResultEvent->InstanceID() == KErrNotFound )

        {

        __LOG1( "CUPnPXMLEventParser::ParseRcEventDataL \

instanceid not matching %d",  iSessionInstanceID );

        User::Leave( KErrNotFound );

        }  

    return CUPnPAVTEvent::CloneL( *iAvtResultEvent );

    }

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

// CUPnPXMLEventParser::ParseAVTEventDataL

// See upnpxmlparser.h

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

EXPORT_C CUPnPAVTEvent* CUPnPXMLEventParser::ParseAvtEventDataL(

    const TDesC8& aData, const TInt aInstanceId )

    {

    __LOG( "CUPnPXMLEventParser::ParseAvtEventDataL, begin" );

    if ( !aData.Length() )

        {

        User::Leave( KErrArgument );

        }

    Reset();

    ResetResult();

    iSessionInstanceID = aInstanceId;

    // 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 );

    if( iAvtResultEvent->InstanceID() == KErrNotFound )

        {

        __LOG1( "CUPnPXMLEventParser::ParseAvtEventDataL \

instanceid not matching %d", iSessionInstanceID );

        User::Leave( KErrNotFound );

        }

    return CUPnPAVTEvent::CloneL( *iAvtResultEvent );

    }

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

// CUPnPXMLEventParser::OnStartDocumentL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::OnStartDocumentL( 

                                const RDocumentParameters& /*aDocParam*/, 

                                TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnEndDocumentL

// See upnpxmlparser.h

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

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

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnStartElementL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::OnStartElementL( const RTagInfo& aElement, 

                                      const RAttributeArray& aAttributes,

                                      TInt aErrorCode )

    {   

    if ( aErrorCode != KErrNone )

        {

        __LOG1( "CUPnPXMLEventParser::OnStartElementL, error: %d",

                                                                aErrorCode );

        return;

        }

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

    __LOG8_1("CUPnPXMLEventParser::OnStartElementL name = %S", &desName );

    if ( !desName.CompareF( KEvent ) )

        {

        iParserState = EEvent;

        }

    else if ( !desName.CompareF( KInstanceID ) )

        {

        iParserState = EInstanceID;

        SetAttributesL( aAttributes );

        }

    //Rc events

    else if( !desName.CompareF( KVolume ) )

        {

        iParserState = EVolume;

        SetAttributesL( aAttributes );

        }

    else if( !desName.CompareF( KMute ) )

        {

        iParserState = EMute;

        SetAttributesL( aAttributes );

        }  

    // Avt events 

    else if( !desName.CompareF( KTransportState ) )

        {

        iParserState = ETransportState;

        SetAttributesL( aAttributes );

        }

    else if ( !desName.CompareF( KTransportURI ) )

        {

        iParserState = ETransportURI;

        SetAttributesL( aAttributes );

        }

    // 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 

        {

        // just print attribute values

        iParserState = ENotSupported;

        SetAttributesL( aAttributes );

        }

    }

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

// CUPnPXMLEventParser::OnEndElementL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::OnEndElementL( const RTagInfo& aElement, 

                                    TInt /*aErrorCode*/ )

    {

    // if we have finished parsing one event,

    // check that it belongs to our session

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

    if ( !desName.CompareF( KInstanceID ) )

        {

        if( iAvtEvent->InstanceID() == iSessionInstanceID )

            {

            iAvtResultEvent->Reset();

            iAvtResultEvent->SetInstanceID( iAvtEvent->InstanceID() );

            iAvtResultEvent->SetMute( iAvtEvent->Mute() );

            iAvtResultEvent->SetVolume( iAvtEvent->Volume() );

            iAvtResultEvent->SetTransportState( iAvtEvent->TransportState() );

            iAvtResultEvent->SetTransportURIL( iAvtEvent->TransportURI() );

            __LOG( "CUPnPXMLEventParser::OnEndElementL() valid event" );

            }

        else

            {

            __LOG2( "CUPnPXMLEventParser OnEndElementL ERROR instanceid not \

matching session %d, event %d", iSessionInstanceID, iAvtEvent->InstanceID());

            }

        Reset();

        }

    }

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

// CUPnPXMLEventParser::OnContentL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::OnContentL( const TDesC8& /*aBytes*/,

    TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnStartPrefixMappingL

// See upnpxmlparser.h

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

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

                                               const RString& /*aUri*/, 

                                               TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnEndPrefixMappingL

// See upnpxmlparser.h

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

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

                                             TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnIgnorableWhiteSpaceL

// See upnpxmlparser.h

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

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

                                                TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnSkippedEntityL

// See upnpxmlparser.h

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

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

                                          TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnProcessingInstructionL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::OnProcessingInstructionL(

    const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt /*aErrorCode*/ )

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::OnError

// See upnpxmlparser.h

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

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

    {

    // No implementation needed

    }

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

// CUPnPXMLEventParser::GetExtendedInterface

// See upnpxmlparser.h

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

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

    {    

    // No implementation needed

    return NULL;

    }

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

// CUPnPXMLEventParser::SetAttributesL

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::SetAttributesL(

    const RAttributeArray& aAttributes )

    {

    RAttribute attribute;

    TInt count = aAttributes.Count();

    TInt volume = KErrNotFound;

    iMasterVolumeState = EFalse;

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

        {

        attribute = aAttributes[i];

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

        const TDesC8& value = attribute.Value().DesC();

        if( value.Length() )

            {

            __LOG8_1( "CUPnPXMLEventParser::SetAttributesL value = %S",

                    &value );

            }

        // volume & channel

        if ( iParserState == EVolume )

            {

            // assign the value of Volume to volume 

            if ( name.CompareF( KVal ) == KErrNone )

                {

                TLex8 lexer( value );

                User::LeaveIfError( lexer.Val(volume) );

                }

            else if ( name.CompareF( KChannel ) == KErrNone )

                {

                // channel is found, check if is Master

                if ( value.CompareF( KMaster ) == KErrNone )

                    {

                    __LOG( "CUPnPXMLEventParser::SetAttributesL - \

MasterVolume found!" );

                    iMasterVolumeState = ETrue;

                    }

                }

            }

        // other values

        else if ( name.Compare( KVal ) == KErrNone )

            {

            TLex8 lexer( value );

            if ( iParserState == EInstanceID )

                {

                TInt id = KErrNotFound;

                User::LeaveIfError( lexer.Val( id ) );

                iAvtEvent->SetInstanceID( id );

                }

            else if ( iParserState == EMute )

                {

                TInt mute = KErrNotFound;

                User::LeaveIfError( lexer.Val( mute ) );

                iAvtEvent->SetMute( mute );

                }

            else if ( iParserState == ETransportState )

                {

                iAvtEvent->SetTransportState( value );

                }

            else if ( iParserState == ETransportURI )

                {

                iAvtEvent->SetTransportURIL( value );

                }

            else

                {

                __LOG( "CUPnPXMLEventParser::SetAttributesL - \

unknown state" );

                }

            }

        }

    // check Mastervolume and volume

    if ( iParserState == EVolume && 

         iMasterVolumeState && 

         volume != KErrNotFound )

        {

        // all is found ,so assign the iVolume

        __LOG1( "CUPnPXMLEventParser::SetAttributesL - set iVolume : %d",

                                                                     volume );

        iAvtEvent->SetVolume( volume );       

        }

    }

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

// CUPnPXMLEventParser::Reset

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::Reset()

    {

    iParserState = ENotSupported;

    iMasterVolumeState = EFalse;

    iAvtEvent->Reset();

    }

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

// CUPnPXMLEventParser::ResetResult

// See upnpxmlparser.h

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

void CUPnPXMLEventParser::ResetResult()

    {

    iSessionInstanceID = KErrNotFound;

    iParserState = ENotSupported;

    iMasterVolumeState = EFalse;

    iAvtResultEvent->Reset();

    }     

// end of file