/*

* 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:      generates XML from an UPNP item

*

*/

// INCLUDE FILES

// System

#include <e32base.h>

// upnp stack api

#include <upnpstring.h>

// dlnasrv / mediaserver api

#include <upnpitem.h>

#include <upnpdlnaprotocolinfo.h>

// dlnasrv / avcontroller helper api

#include "upnpconstantdefs.h" // for upnp definitions

#include "upnpitemutility.h"

// xmlparser internal

#include "upnpitemtoxml.h"

_LIT( KComponentLogfile, "upnpxmlparser.txt");

#include "upnplog.h"

// CONSTANTS

_LIT8(KItemHeading1,            "<item id=\"");

_LIT8(KItemHeading2,            "\" parentID=\"");

_LIT8(KItemHeading3False,       "\" restricted=\"0\">");

_LIT8(KItemHeading3True,        "\" restricted=\"1\">");

_LIT8(KItemTitleBegin,          "<dc:title>");

_LIT8(KItemTitleEnd,            "</dc:title>");

_LIT8(KItemDateBegin,           "<dc:date>");

_LIT8(KItemDateEnd,             "</dc:date>");

_LIT8(KItemClassBegin,          "<upnp:class>");

_LIT8(KItemClassEnd,            "</upnp:class>");

_LIT8(KItemPInfoEmpty,          "<res protocolInfo=\"*:*:*:*\"></res>");

_LIT8(KItemPInfoEmptyDlna,      "<res protocolInfo=\"*:*:");

_LIT8(KDlnaPn,                  "DLNA.ORG_PN=" );

_LIT8(KColon,                   ":"); 

_LIT8(KItemPInfoBegin,          "<res protocolInfo=\"");

_LIT8(KItemPInfoMiddle,         ">");

_LIT8(KItemPInfoEnd,            "</res>");

_LIT8(KItemPInfoEnd2,            "\"></res>");

_LIT8(KItemEnd,                 "</item>");

_LIT8(KEqual,                   "=");

_LIT8(KQuotationMark,           "\" ");

_LIT8(KItemSize,                "size=\"");

_LIT8(KItemDuration,            "duration=\"");

_LIT8(KItemResolution,          "resolution=\"");

// Music metadata

_LIT8(KItemArtistBegin,         "<upnp:artist>");

_LIT8(KItemArtistEnd,           "</upnp:artist>");

_LIT8(KItemCreatorBegin,        "<dc:creator>");

_LIT8(KItemCreatorEnd,          "</dc:creator>");

_LIT8(KItemAlbumBegin,          "<upnp:album>");

_LIT8(KItemAlbumEnd,            "</upnp:album>");

_LIT8(KItemGenreBegin,          "<upnp:genre>");

_LIT8(KItemGenreEnd,            "</upnp:genre>");

_LIT8(KItemAlbumArtURIBegin,    "<upnp:albumArtURI>");

_LIT8(KItemAlbumArtURI,         "<upnp:albumArtURI ");

_LIT8(KItemAlbumArtURIEnd,      "</upnp:albumArtURI>");

_LIT8(KDIDLBeginXmlEscaped,

    "<DIDL-Lite "

    "xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" "

    "xmlns:dc="http://purl.org/dc/elements/1.1/" "

    "xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/""

    ">");

_LIT8(KDIDLEndXmlEscaped, "</DIDL-Lite>");

_LIT8( KAsterisk, "*" );

const TInt KBufLen = 256;

const TInt KDateStringLength        = 10;

const TInt KDateTimeStringLength    = 19;

const TInt KMaxDateStringLength     = 30;

const TInt KSeparatorAscii          = 58;

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

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

// CUpnpItemToXML::CUpnpItemToXML

// C++ default constructor can NOT contain any code, that

// might leave.

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

CUpnpItemToXML::CUpnpItemToXML( const CUpnpItem& aItem ) :

    iItem( const_cast<CUpnpItem*>(&aItem) )

    {

    }

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

// CUpnpItemToXML::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CUpnpItemToXML::ConstructL()

    {

    }

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

// CUpnpItemToXML::NewL

// Two-phased constructor.

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

CUpnpItemToXML* CUpnpItemToXML::NewL( const CUpnpItem& aItem )

    {

    CUpnpItemToXML* self = CUpnpItemToXML::NewLC( aItem );

    CleanupStack::Pop();

    return self;

    }

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

// CUpnpItemToXML::NewLC

// Two-phased constructor.

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

CUpnpItemToXML* CUpnpItemToXML::NewLC( const CUpnpItem& aItem )

    {

    CUpnpItemToXML* self = new( ELeave ) CUpnpItemToXML( aItem );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CUpnpItemToXML::~CUpnpItemToXML()

    {

    }

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

// CUpnpItemToXML::AsXmlL

// Returns XML buffer

// (other items were commented in a header).

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

HBufC8* CUpnpItemToXML::AsXmlL( const TBool /*aIncludeChilds = ETrue */ ) 

    {

    __LOG( "CUpnpItemToXML::AsXmlL" );

    const TInt bufferSize = 64; // Buffer size, grows dynamicly in 64b steps

    CBufFlat *pBuf = CBufFlat::NewL( bufferSize );

    CleanupStack::PushL( pBuf );

    RBufWriteStream stream( *pBuf );

    CleanupClosePushL( stream );

    // Then add the actual data

    stream.WriteL( KItemHeading1() );

    // xml encoding added

    HBufC8* encodeTemp = HBufC8::NewLC( iItem->Id().Length() );

    encodeTemp->Des().Copy( iItem->Id() );

    HBufC8* tempPtr = NULL;

    tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

    CleanupStack::PushL( tempPtr );

    stream.WriteL( *tempPtr );

    CleanupStack::PopAndDestroy( tempPtr );

    tempPtr = NULL;

    CleanupStack::PopAndDestroy( encodeTemp );

    encodeTemp = NULL;

    stream.WriteL( KItemHeading2() );

    stream.WriteL( iItem->ParentId() );

    if (iItem->Restricted())

        {

        stream.WriteL( KItemHeading3True() );

        }

    else

        {

        stream.WriteL( KItemHeading3False() );

        }

    stream.WriteL( KItemTitleBegin() );

    // xml encoding added

    encodeTemp = HBufC8::NewLC( iItem->Title().Length() );

    encodeTemp->Des().Copy( iItem->Title() );

    tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

    CleanupStack::PushL( tempPtr );

    stream.WriteL( *tempPtr );

    CleanupStack::PopAndDestroy( tempPtr );

    tempPtr = NULL;

    CleanupStack::PopAndDestroy( encodeTemp );

    encodeTemp = NULL;    

    stream.WriteL( KItemTitleEnd() );

    stream.WriteL( KItemClassBegin() );

    stream.WriteL( iItem->ObjectClass() );

    stream.WriteL( KItemClassEnd() );

     // Music meta data information

    const TDesC8& artist = GetValueFromElement( KElementArtist ); 

    if ( artist != KNullDesC8 )

        {

        stream.WriteL( KItemArtistBegin );

        // xml encoding added

        encodeTemp = HBufC8::NewLC( artist.Length() );

        encodeTemp->Des().Copy( artist );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        stream.WriteL( KItemArtistEnd );

        }

    const TDesC8& creator = GetValueFromElement( KElementCreator ); 

    if ( creator != KNullDesC8 )

        {

        stream.WriteL( KItemCreatorBegin );

        // xml encoding added

        encodeTemp = HBufC8::NewLC( creator.Length() );

        encodeTemp->Des().Copy( creator );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        stream.WriteL( KItemCreatorEnd );

        }

    const TDesC8& album = GetValueFromElement( KElementAlbum ); 

    if ( album != KNullDesC8 )

        {

        stream.WriteL( KItemAlbumBegin );

        // xml encoding added

        encodeTemp = HBufC8::NewLC( album.Length() );

        encodeTemp->Des().Copy( album );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        //stream.WriteL( Album() );

        stream.WriteL( KItemAlbumEnd );

        }

    const TDesC8& genre = GetValueFromElement( KElementGenre );     

    if ( genre != KNullDesC8 )

        {

        stream.WriteL( KItemGenreBegin );

        // xml encoding added

        encodeTemp = HBufC8::NewLC( genre.Length() );

        encodeTemp->Des().Copy( genre );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        //stream.WriteL( Genre() );

        stream.WriteL( KItemGenreEnd );

        } 

    const TDesC8& albumarturi = GetValueFromElement( KElementAlbumArtUri );

    if ( albumarturi != KNullDesC8 )

        {

        CUpnpElement* elem = 

        (CUpnpElement*)(UPnPItemUtility::FindElementByName( *iItem, KElementAlbumArtUri() ));

        if( elem )

            {

            stream.WriteL( KItemAlbumArtURI );

            const RUPnPAttributesArray& attrArray = elem->GetAttributes();

            for( TInt i(0); i < attrArray.Count(); ++i )

                {

                stream.WriteL( attrArray.operator [](i)->Name() );

                stream.WriteL( KEqual );

                stream.WriteL( KCriteriaQuot );

                stream.WriteL( attrArray.operator [](i)->Value() ); 

                stream.WriteL( KCriteriaQuot );

                }            

            stream.WriteL( KItemPInfoMiddle );

            }

        else

            {

            stream.WriteL( KItemAlbumArtURIBegin );

            }

        // xml encoding added

        encodeTemp = HBufC8::NewLC( albumarturi.Length() );

        encodeTemp->Des().Copy( albumarturi );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;        

        stream.WriteL( KItemAlbumArtURIEnd );

        }

    const TDesC8& date = GetValueFromElement( KElementDate );         

    if ( date != KNullDesC8 )

        {        

        if( ValidateDateL( date ) )

            {

            stream.WriteL( KItemDateBegin );

            // xml encoding added

            encodeTemp = HBufC8::NewLC( date.Length() );

            encodeTemp->Des().Copy( date );

            tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

            CleanupStack::PushL( tempPtr );

            stream.WriteL( *tempPtr );

            CleanupStack::PopAndDestroy( tempPtr );

            tempPtr = NULL;

            CleanupStack::PopAndDestroy( encodeTemp );

            encodeTemp = NULL;

            stream.WriteL( KItemDateEnd );

            }

        }

    RUPnPElementsArray elArray;

    CleanupClosePushL( elArray );

    UPnPItemUtility::GetResElements( *iItem, elArray );

    TInt count = elArray.Count();

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

        {

        // Res-element starts

        stream.WriteL( KItemPInfoBegin );

        const CUpnpAttribute* attrproinfo = UPnPItemUtility

            ::FindAttributeByName( *elArray[ i ], KAttributeProtocolInfo );

        if ( attrproinfo )

            {        

            stream.WriteL( attrproinfo->Value() );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( KCriteriaSpace );

            }

        const CUpnpAttribute* attrsize = UPnPItemUtility

            ::FindAttributeByName( *elArray[ i ], KAttributeSize );            

        if ( attrsize )

            {

            stream.WriteL( KAttributeSize );

            stream.WriteL( KCriteriaEQ );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( attrsize->Value() );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( KCriteriaSpace );                   

            }         

        const CUpnpAttribute* attrresolution = UPnPItemUtility

            ::FindAttributeByName( *elArray[ i ], KAttributeResolution );

        if ( attrresolution )

            {

            stream.WriteL( KAttributeResolution );

            stream.WriteL( KCriteriaEQ );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( attrresolution->Value() );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( KCriteriaSpace );                        

            }        

        const CUpnpAttribute* attrduration = UPnPItemUtility

            ::FindAttributeByName( *elArray[ i ], KAttributeDuration );

        if ( attrduration )

            {           

            if( ValidateDurationL( attrduration->Value() ) )

                {

                stream.WriteL( KAttributeDuration );

                stream.WriteL( KCriteriaEQ );

                stream.WriteL( KCriteriaQuot );

                stream.WriteL( attrduration->Value() );

                stream.WriteL( KCriteriaQuot );

                stream.WriteL( KCriteriaSpace );

                }

            else

                {

                // Format of duration is not valid, do not include it

                // Fixes ESLX-7AYFD6

                }    

            }        

        const CUpnpAttribute* attrbitrate = UPnPItemUtility

            ::FindAttributeByName( *elArray[ i ], KAttributeBitrate );

        if ( attrbitrate )

            {

            stream.WriteL( KAttributeBitrate );

            stream.WriteL( KCriteriaEQ );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( attrbitrate->Value() );

            stream.WriteL( KCriteriaQuot );

            stream.WriteL( KCriteriaSpace );

            } 

        stream.WriteL( KItemPInfoMiddle );

        // Get the content URI

        encodeTemp = HBufC8::NewLC( elArray[ i ]->Value().Length() );

        encodeTemp->Des().Copy( elArray[ i ]->Value() );

        // Encode the content URI

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        // Write the encoded content URI

        stream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        // Clean up

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        // Res-element ends

        stream.WriteL( KItemPInfoEnd );

        }

    CleanupStack::PopAndDestroy( &elArray );                  

    stream.WriteL( KItemEnd() );

    CleanupStack::PopAndDestroy(); // stream.Close();

    TPtrC8 start = pBuf->Ptr(0);

    // JLi: Do NOT decode retBuffer since it will be given to XML Parser

    HBufC8* retBuffer = start.AllocL();

    CleanupStack::PopAndDestroy( pBuf );

    return retBuffer;

    }

void CUpnpItemToXML::FillMetaDataL(RBufWriteStream& aStream)

    {

    HBufC8* encodeTemp = NULL;

    HBufC8* tempPtr = NULL;

    const TDesC8& artist = GetValueFromElement( KElementArtist ); 

    if ( artist != KNullDesC8 )

        {

        aStream.WriteL( KItemArtistBegin );

        // xml encoding added

        encodeTemp = HBufC8::NewLC( artist.Length() );

        encodeTemp->Des().Copy( artist );

        tempPtr = UpnpString::EncodeXmlStringL( encodeTemp );

        CleanupStack::PushL( tempPtr );

        aStream.WriteL( *tempPtr );

        CleanupStack::PopAndDestroy( tempPtr );

        tempPtr = NULL;

        CleanupStack::PopAndDestroy( encodeTemp );

        encodeTemp = NULL;

        aStream.WriteL( KItemArtistEnd );

        }