/*

* Copyright (c) 2004 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:  WV InfoLink implementation.

*

*/

// INCLUDE FILES

#include "CPEngWVAttributeConstructBase.h"

#include "CPEngWVAttributeModelBase.h"

#include "CPEngWVInfoLinkConstruct.h"

#include "PEngWVAttributeModelDataHelper.h"

#include "MPEngXMLSerializer.h"

#include "MPEngXMLParser.h"

#include <MPEngPresenceAttrModel2.h>

#include <PEngWVPresenceAttributes2.h>

#include <E32Base.h>

#include <S32Strm.h>

//  DATA TYPES

/**

 * InfoLink WV CSP name table and size.

 */

const TWVCspAttributeNameEntry KInfoLinkCspNameTable[] =

    {

        {

        EWVCspV12,

        LIT_AS_DESC8_PTR( KInfoLinkXMLTag ),

        LIT_AS_DESC8_PTR( KPresenceSubListAttributesNS_CSP12 )

        }

    };

const TInt KInfoLinkCspNameTableCount = sizeof( KInfoLinkCspNameTable ) / sizeof( TWVCspAttributeNameEntry );

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

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkConstruct

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

// might leave.

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

//

CPEngWVInfoLinkConstruct::CPEngWVInfoLinkConstruct( TPEngWVCspVersion aCurrentCspVer )

        : CPEngWVAttributeConstructBase( aCurrentCspVer,

                                         KInfoLinkCspNameTable,

                                         KInfoLinkCspNameTableCount )

    {

    }

// Destructor

CPEngWVInfoLinkConstruct::~CPEngWVInfoLinkConstruct()

    {

    }

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

// CPEngWVInfoLinkConstruct::NewAttributeInstanceLC()

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

//

MPEngPresenceAttrModelTypeImp* CPEngWVInfoLinkConstruct::NewAttributeInstanceLC(

    TBool aUserOwnAttribute ) const

    {

    CPEngWVInfoLinkModel* model = new ( ELeave ) CPEngWVInfoLinkModel(

        aUserOwnAttribute );

    CleanupStack::PushL( model );

    model->ResetDataL();

    return model;

    }

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

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::NewL()

// Two-phased constructor.

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

//

CPEngWVInfoLinkConstruct::CPEngWVInfoLink*

CPEngWVInfoLinkConstruct::CPEngWVInfoLink::NewLC()

    {

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

    CleanupStack::PushL( self );

    return self;

    }

CPEngWVInfoLinkConstruct::CPEngWVInfoLink*

CPEngWVInfoLinkConstruct::CPEngWVInfoLink::NewLC( RReadStream& aStream )

    {

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

    CleanupStack::PushL( self );

    self->InternalizeL( aStream );

    return self;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::CPEngWVInfoLink

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

// might leave.

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

//

CPEngWVInfoLinkConstruct::CPEngWVInfoLink::CPEngWVInfoLink()

    {

    }

// Destructor

CPEngWVInfoLinkConstruct::CPEngWVInfoLink::~CPEngWVInfoLink()

    {

    delete iInfoLink;

    delete iInfoLinkDescr;

    delete iInfoLinkMimeType;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetUrlL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetUrlL( const TDesC& aUrl )

    {

    DoSetDescL( iInfoLink, aUrl );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetDescriptionL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetDescriptionL( const TDesC& aDescr )

    {

    DoSetDescL( iInfoLinkDescr, aDescr );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetMimeTypeL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::SetMimeTypeL( const TDesC& aMimeType )

    {

    DoSetDescL( iInfoLinkMimeType, aMimeType );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetUrl()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetUrl( TPtrC16& aUrl ) const

    {

    DoGetDesc( iInfoLink, aUrl );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetDescription()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetDescription( TPtrC16& aDescr ) const

    {

    DoGetDesc( iInfoLinkDescr, aDescr );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetMimeType()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::GetMimeType( TPtrC16& aMimeType ) const

    {

    DoGetDesc( iInfoLinkMimeType, aMimeType );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::ExternalizeSize()

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

//

TInt CPEngWVInfoLinkConstruct::CPEngWVInfoLink::ExternalizeSize() const

    {

    TInt size = DoGetBufExtSize( iInfoLink );

    size += DoGetBufExtSize( iInfoLinkDescr );

    size += DoGetBufExtSize( iInfoLinkMimeType );

    return size;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::ExternalizeL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::ExternalizeL(

    RWriteStream& aStream ) const

    {

    DoExtrBufL( iInfoLink, aStream );

    DoExtrBufL( iInfoLinkDescr, aStream );

    DoExtrBufL( iInfoLinkMimeType, aStream );

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLink::InternalizeL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLink::InternalizeL( RReadStream& aStream )

    {

    TPtr16 dataStrait( NULL, 0 );

    DoIntrBufL( iInfoLink, dataStrait, aStream );

    DoIntrBufL( iInfoLinkDescr, dataStrait, aStream );

    DoIntrBufL( iInfoLinkMimeType, dataStrait, aStream );

    }

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

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel

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

// might leave.

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

//

CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::CPEngWVInfoLinkModel(

    TBool aUserOwnAttribute )

        : CPEngWVAttributeModelBase( aUserOwnAttribute )

    {

    }

// Destructor

CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::~CPEngWVInfoLinkModel()

    {

    iInfoLinks.ResetAndDestroy();

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::SetDataL()

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

//

TBool CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::SetDataL( TInt* aIntData,

                                                                const TDesC8* /*a8Data*/,

                                                                const TDesC16* a16Data,

                                                                TInt aField,

                                                                TInt aGroup )

    {

    TBool handled = EFalse;

    if ( a16Data )

        {

        //Updating infoLink struct contents

        if ( aGroup == iInfoLinks.Count() )

            {

            // initialize the cell where the new data is about to be put

            CPEngWVInfoLink* link = CPEngWVInfoLink::NewLC();

            handled = SetInfoLinkDataL( *link, *a16Data, aField );

            if ( handled )

                {

                iInfoLinks.AppendL( link );

                CleanupStack::Pop( link );

                }

            else

                {

                CleanupStack::PopAndDestroy( link );

                }

            }

        else

            {

            CPEngWVInfoLink* link = iInfoLinks[ aGroup ];

            handled = SetInfoLinkDataL( *link, *a16Data, aField );

            }

        }

    else if ( aIntData )

        {

        //Editing infoLink struct amount

        if ( ( aGroup == EPEngInfoLinkOperations ) &&

             ( aField == EPEngInfoLinkOpDeleteGroup ) )

            {

            TInt index = *aIntData;

            //If client gives special index -1, all existing infolinks are deleted

            if ( index == -1 )

                {

                iInfoLinks.ResetAndDestroy();

                }

            else

                {

                delete iInfoLinks[ *aIntData ];

                iInfoLinks.Remove( *aIntData );

                }

            handled = ETrue;

            }

        }

    return handled;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::GetData()

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

//

TBool CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::GetData( TInt* aIntData,

                                                               TPtrC8* /*a8Data*/,

                                                               TPtrC16* a16Data,

                                                               TInt aField,

                                                               TInt aGroup ) const

    {

    TBool handled = EFalse;

    if ( a16Data )

        {

        const CPEngWVInfoLink& infoLink = *iInfoLinks[ aGroup ];

        handled = GetInfoLinkData( infoLink, aField, *a16Data );

        }

    else if ( aIntData )

        {

        if ( ( aGroup == EPEngInfoLinkOperations ) &&

             ( aField == EPEngInfoLinkOpGetGroupCount ) )

            {

            *aIntData = iInfoLinks.Count();

            handled = ETrue;

            }

        }

    return handled;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::EncodeDataToXmlL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::EncodeDataToXmlL(

    MPEngXMLSerializer& aSerializer ) const

    {

    const TInt infLinkCount = iInfoLinks.Count();

    for ( TInt ix = 0; ix < infLinkCount; ix++ )

        {

        const CPEngWVInfoLink& infoLink = *iInfoLinks[ ix ];

        TPtrC16 data( NULL, 0 );

        aSerializer.StartTagL( KInfoLinkXMLTagInf );

        infoLink.GetUrl( data );

        aSerializer.StartTagL( KInfoLinkXMLTagLink )

        .UnicodeTextL( data )

        .EndTagL( KInfoLinkXMLTagLink );

        infoLink.GetDescription( data );

        aSerializer.StartTagL( KInfoLinkXMLTagText )

        .UnicodeTextL( data )

        .EndTagL( KInfoLinkXMLTagText );

        infoLink.GetMimeType( data );

        aSerializer.StartTagL( KContentTypeXMLTag )

        .UnicodeTextL( data )

        .EndTagL( KContentTypeXMLTag );

        aSerializer.EndTagL( KInfoLinkXMLTagInf );

        }

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::DecodeDataFromXmlL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::DecodeDataFromXmlL(

    MPEngXMLParser& aParser,

    const TDesC8& aValueBlock )

    {

    RArray<TPtrC8> infoLinkDataBlocks;

    CleanupClosePushL( infoLinkDataBlocks );

    iInfoLinks.ResetAndDestroy();

    // parse the InfoLink attribute values

    if ( aParser.DecodeL( aValueBlock, KInfoLinkXMLTagInf, ETrue ) )

        {

        const TInt resCount( aParser.Count() );

        TInt ix;

        for ( ix = 0; ix < resCount; ix++ )

            {

            User::LeaveIfError( infoLinkDataBlocks.Append( aParser.ResultL( ix ) ) );

            }

        for ( ix = 0; ix < resCount; ix++ )

            {

            TPtrC8 infoLinkBlock( infoLinkDataBlocks[ ix ] );

            CPEngWVInfoLink* infoLink = CPEngWVInfoLink::NewLC();

            TBool mandatoryFieldsFound = EFalse;

            if ( aParser.DecodeL( infoLinkBlock, KInfoLinkXMLTagLink, EFalse ) )

                {

                HBufC* tmp = aParser.ResultAsUnicodeTextL();

                CleanupStack::PushL( tmp );

                infoLink->SetUrlL( *tmp );

                CleanupStack::PopAndDestroy(); // tmp

                mandatoryFieldsFound = ETrue;

                }

            if ( aParser.DecodeL( infoLinkBlock, KInfoLinkXMLTagText, EFalse ) )

                {

                HBufC* tmp = aParser.ResultAsUnicodeTextL();

                CleanupStack::PushL( tmp );

                infoLink->SetDescriptionL( *tmp );

                CleanupStack::PopAndDestroy(); // tmp

                }

            if ( aParser.DecodeL( infoLinkBlock, KContentTypeXMLTag, EFalse ) )

                {

                HBufC* tmp = aParser.ResultAsUnicodeTextL();

                CleanupStack::PushL( tmp );

                infoLink->SetMimeTypeL( *tmp );

                CleanupStack::PopAndDestroy(); // tmp

                }

            if ( mandatoryFieldsFound )

                {

                iInfoLinks.AppendL( infoLink );

                CleanupStack::Pop( infoLink );

                }

            else

                {

                CleanupStack::PopAndDestroy( infoLink );

                }

            }

        }

    CleanupStack::PopAndDestroy(); // infoLinks

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::ResetDataL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::ResetDataL()

    {

    iInfoLinks.ResetAndDestroy();

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::DataExternalizeSize()

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

//

TInt CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::DataExternalizeSize() const

    {

    TInt dataSize = 4; // 4 is the max size of the count

    const TInt infLinkCount( iInfoLinks.Count() );

    for ( TInt ix = 0; ix < infLinkCount; ix++ )

        {

        dataSize += iInfoLinks[ ix ]->ExternalizeSize();

        }

    return dataSize;

    }

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

// CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::ExternalizeDataL()

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

//

void CPEngWVInfoLinkConstruct::CPEngWVInfoLinkModel::ExternalizeDataL(

    RWriteStream& aStream ) const

    {

    const TInt infLinkCount( iInfoLinks.Count() );

    aStream << TCardinality( infLinkCount );

    for ( TInt ix = 0; ix < infLinkCount; ix++ )

        {

        iInfoLinks[ ix ]->ExternalizeL( aStream );

        }

    }

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