/*

* 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 Comm Cap implementation.

*

*/

// INCLUDE FILES

#include "CPEngWVAttributeConstructBase.h"

#include "CPEngWVAttributeModelBase.h"

#include "CPEngWVCommCapConstruct.h"

#include "MPEngXMLSerializer.h"

#include "MPEngXMLParser.h"

#include <MPEngPresenceAttrModel2.h>

#include <E32Base.h>

#include <S32Strm.h>

//  DATA TYPES

/**

 * CommCap CSP name table.

 *

 * @since 3.0

 */

const TWVCspAttributeNameEntry KCommCapCspNameTable[] =

    {

        {

        EWVCspV11,

        LIT_AS_DESC8_PTR( KCommCapXMLTag ),

        LIT_AS_DESC8_PTR( KPresenceSubListAttributesNS )

        },

        {

        EWVCspV12,

        LIT_AS_DESC8_PTR( KCommCapXMLTag ),

        LIT_AS_DESC8_PTR( KPresenceSubListAttributesNS_CSP12 )

        }

    };

const TInt KCommCapCspNameTableCount = sizeof( KCommCapCspNameTable ) / sizeof( TWVCspAttributeNameEntry );

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

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

// CPEngWVCommCapConstruct::CPEngWVCommCapConstruct

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

// might leave.

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

//

CPEngWVCommCapConstruct::CPEngWVCommCapConstruct( TPEngWVCspVersion aCurrentCspVer )

        : CPEngWVAttributeConstructBase( aCurrentCspVer,

                                         KCommCapCspNameTable,

                                         KCommCapCspNameTableCount )

    {

    }

// Destructor

CPEngWVCommCapConstruct::~CPEngWVCommCapConstruct()

    {

    }

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

// CPEngWVCommCapConstruct::NewAttributeInstanceLC()

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

//

MPEngPresenceAttrModelTypeImp* CPEngWVCommCapConstruct::NewAttributeInstanceLC(

    TBool aUserOwnAttribute ) const

    {

    CPEngWVCommCapModel* model = new ( ELeave ) CPEngWVCommCapModel(

        aUserOwnAttribute );

    CleanupStack::PushL( model );

    model->ResetDataL();

    return model;

    }

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

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

// CPEngWVCommCapConstruct::CPEngWVCommCapConstruct::CPEngWVCommCapModel

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

// might leave.

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

//

CPEngWVCommCapConstruct::CPEngWVCommCapModel::CPEngWVCommCapModel(

    TBool aUserOwnAttribute )

        : CPEngWVAttributeModelBase( aUserOwnAttribute )

    {

    }

// Destructor

CPEngWVCommCapConstruct::CPEngWVCommCapModel::~CPEngWVCommCapModel()

    {

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::SetDataL()

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

//

TBool CPEngWVCommCapConstruct::CPEngWVCommCapModel::SetDataL( TInt* aIntData,

                                                              const TDesC8* /*a8Data*/,

                                                              const TDesC16* /*a16Data*/,

                                                              TInt aField,

                                                              TInt aGroup )

    {

    TBool handled = EFalse;

    if ( aIntData && ( aField == EPEngCommCapStatus ) )

        {

        switch ( aGroup ) //from TPEngCommunicationCapabilitiesFieldGroups

            {

            case EPEngCommCapIMClient:

                {

                DoSetCapabilityStatusL( iIMCapability, *aIntData );

                handled = ETrue;

                break;

                }

            }

        }

    return handled;

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::GetData()

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

//

TBool CPEngWVCommCapConstruct::CPEngWVCommCapModel::GetData( TInt* aIntData,

                                                             TPtrC8* /*a8Data*/,

                                                             TPtrC16* /*a16Data*/,

                                                             TInt aField,

                                                             TInt aGroup ) const

    {

    TBool handled = EFalse;

    if ( aIntData && ( aField == EPEngCommCapStatus ) )

        {

        switch ( aGroup ) //from TPEngCommunicationCapabilitiesFieldGroups

            {

            case EPEngCommCapIMClient:

                {

                *aIntData = iIMCapability;

                handled = ETrue;

                break;

                }

            }

        }

    return handled;

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::EncodeDataToXmlL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::EncodeDataToXmlL(

    MPEngXMLSerializer& aSerializer ) const

    {

    aSerializer.StartTagL( KCommCXMLTag );

        {

        aSerializer.StartTagL( KCommCapXMLTagCap ).RawValueL( KCommCapIMXMLTag ).EndTagL( KCommCapXMLTagCap );

        aSerializer.StartTagL( KCommCapStatusXMLTag );

            {

            switch ( iIMCapability )

                {

                case EPEngCommCapStatusOpen:

                    {

                    aSerializer.RawValueL( KCommCapStatusOpen );

                    break;

                    }

                case EPEngCommCapStatusClosed:

                default:

                    {

                    aSerializer.RawValueL( KCommCapStatusClosed );

                    break;

                    }

                }

            }

        aSerializer.EndTagL( KCommCapStatusXMLTag );

        aSerializer.StartTagL( KCommCapNoteXMLTag ).EndTagL( KCommCapNoteXMLTag );

        }

    aSerializer.EndTagL( KCommCXMLTag );

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::DecodeDataFromXmlL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::DecodeDataFromXmlL(

    MPEngXMLParser& aParser,

    const TDesC8& aValueBlock )

    {

    RArray<TPtrC8> commCaps;

    CleanupClosePushL( commCaps );

    // parse the commcap attribute values

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

        {

        TInt count( aParser.Count() );

        for ( TInt resCount( 0 ); resCount < count; resCount++ )

            {

            User::LeaveIfError( commCaps.Append( aParser.ResultL( resCount ) ) );

            }

        count = commCaps.Count();

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

            {

            if ( aParser.DecodeL( commCaps[i], KCommCapXMLTagCap, EFalse ) )

                {

                if ( aParser.ResultL().CompareF( KCommCapIMXMLTag ) == 0 )

                    {

                    if ( aParser.DecodeL( commCaps[i], KCommCapStatusXMLTag, EFalse ) )

                        {

                        if ( aParser.ResultL().CompareF( KCommCapStatusOpen ) == 0 )

                            {

                            iIMCapability = EPEngCommCapStatusOpen;

                            }

                        else

                            {

                            iIMCapability = EPEngCommCapStatusClosed;

                            }

                        }

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy(); //commCaps

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::ResetDataL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::ResetDataL()

    {

    iIMCapability = EPEngCommCapStatusClosed;

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::DataExternalizeSize()

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

//

TInt CPEngWVCommCapConstruct::CPEngWVCommCapModel::DataExternalizeSize() const

    {

    return 1; //iIMCapability is stored to 8 bit

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::ExternalizeDataL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::ExternalizeDataL(

    RWriteStream& aStream ) const

    {

    aStream.WriteInt8L( iIMCapability );

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::InternalizeDataL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::InternalizeDataL(

    RReadStream& aStream )

    {

    iIMCapability = static_cast<TPEngWVCommunicationCapabilityValues> ( aStream.ReadInt8L() );

    }

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

// CPEngWVCommCapConstruct::CPEngWVCommCapModel::DoSetCapabilityStatusL()

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

//

void CPEngWVCommCapConstruct::CPEngWVCommCapModel::DoSetCapabilityStatusL(

    TPEngWVCommunicationCapabilityValues& aCapabilityHolder,

    TInt aNewStatus )

    {

    //validate the data

    switch ( aNewStatus )

        {

            //from TPEngCommunicationCapabilityStatus

        case EPEngCommCapStatusOpen:

        case EPEngCommCapStatusClosed:

            {

            aCapabilityHolder = static_cast<TPEngWVCommunicationCapabilityValues> ( aNewStatus );

            break;

            }

        default:

            {

            __AssertAttrEnumValueOutOfBoundsL();

            break;

            }

        }

    }

//  End of File