/*

* Copyright (c) 2006 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:   CNcdRequestConfigurationData implementation

*

*/

#include "ncdrequestconfigurationdata.h"

#include "ncdrequestconstants.h"

#include "ncdprotocolutils.h"

#include "ncdprotocolwords.h"

#include "ncd_cp_cookie.h"

#include "ncd_cp_detail.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

void CloseStringArray( 

    RArray< TXmlEngString >& aArray )

    {

    TInt count = aArray.Count();

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

        {

        aArray[ i ].Free();

        }

    aArray.Close();

    }

TXmlEngElement GetDetailsElementL(

    RXmlEngDocument& aDocument, 

    const MNcdConfigurationProtocolDetail& aDetails,

    const TXmlEngString& aPrefix )

    {

    DLTRACEIN((""));

    TXmlEngElement detail = NcdProtocolUtils::NewElementL( 

        aDocument, KTagDetail, aPrefix );

    if ( aDetails.GroupId() != KNullDesC )

        NcdProtocolUtils::NewAttributeL( detail, KAttrGroupId, 

            aDetails.GroupId() );

    if ( aDetails.Label() != KNullDesC )

        NcdProtocolUtils::NewAttributeL( detail, KAttrLabel, 

            aDetails.Label() );

    if ( aDetails.Id() != KNullDesC )    

        NcdProtocolUtils::NewAttributeL( detail, KAttrId, 

            aDetails.Id() );

    if ( aDetails.Value() != KNullDesC )

        NcdProtocolUtils::NewAttributeL( detail, KAttrValue, 

            aDetails.Value() );

    for ( TInt j = 0; j < aDetails.Contents().Count(); ++j ) 

        {

        MNcdConfigurationProtocolContent* cont = aDetails.Contents()[j];

        TXmlEngElement content = NcdProtocolUtils::NewElementL( 

            aDocument, detail, KTagContent );

        NcdProtocolUtils::NewAttributeL( content, KAttrKey, cont->Key() );

        NcdProtocolUtils::NewAttributeL( content, KAttrValue, cont->Value() );

        }

    for ( TInt j = 0; j < aDetails.Details().Count(); ++j ) 

        {

        // get elements recursively

        TXmlEngElement child = GetDetailsElementL( aDocument, 

            *(aDetails.Details()[j]), aPrefix );

        detail.AppendChildL(child);

        }

    /*

    for ( TInt j = 0; j < aDetails.xmlFragment.Count(); ++j ) 

        {

        TNcdRequestCustomXmlFragment xmlFrag = aDetails.xmlFragment[j];

        TXmlEngElement xmlFragment = detail.AddNewElementL(

            NcdProtocolUtils::DesToStringL( KTagXmlFragment ) );

        }

    */

    DLTRACEOUT((""));

    return detail;

    }

/**

 * Software-element for client-elements

 */

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

// 

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

// 

CNcdRequestConfigurationSoftware* CNcdRequestConfigurationSoftware::NewLC()

    {

    CNcdRequestConfigurationSoftware* self = new(ELeave) 

        CNcdRequestConfigurationSoftware;

    CleanupStack::PushL( self );

    return self;

    }

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

// 

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

//    

CNcdRequestConfigurationSoftware::~CNcdRequestConfigurationSoftware()

    {

    iSoftware.type.Free();

    iSoftware.version.Free();

    iSoftware.uid.Free();

    iSoftware.id.Free();

    iSoftware.ssid.Free();

    iSoftware.language.Free();    

    CloseStringArray( iSoftware.capabilities );

    iSoftware.details.ResetAndDestroy();

    }

void CNcdRequestConfigurationSoftware::SetSoftwareTypeL( 

    const TDesC& aType )

    {

    iSoftware.type.SetL(aType);

    }

void CNcdRequestConfigurationSoftware::SetSoftwareVersionL( 

    const TDesC& aVersion )

    {

    DLTRACEIN((""));

    iSoftware.version.SetL(aVersion);

    DLTRACEOUT((""));

    }

void CNcdRequestConfigurationSoftware::SetSoftwareIdsL( 

    const TDesC& aUid, const TDesC& aId, const TDesC8& aSsid )

    {

    if (aUid != KNullDesC)

        iSoftware.uid.SetL(aUid);

    if (aId != KNullDesC)

        iSoftware.id.SetL(aId);

    if (aSsid != KNullDesC8)

        iSoftware.ssid.SetL(aSsid);

    }

void CNcdRequestConfigurationSoftware::SetSoftwareLanguageL( 

    const TDesC& aLanguage )

    {

    iSoftware.language.SetL(aLanguage);

    }

void CNcdRequestConfigurationSoftware::AddSoftwareCapabilityL( 

    const TDesC& aCapability )

    {

    TXmlEngString capability;

    capability.SetL(aCapability);

    if ( iSoftware.capabilities.Append(capability) != KErrNone )

        {

        capability.Free();

        }

    }

void CNcdRequestConfigurationSoftware::AddSoftwareDetailsL( 

    MNcdConfigurationProtocolDetail* aDetail)

    {

    iSoftware.details.AppendL(aDetail);

    }

TXmlEngElement CNcdRequestConfigurationSoftware::GetSoftwareConfigurationElementL(

    RXmlEngDocument& aDocument, const TXmlEngString& aPrefix )

    {

    DLTRACEIN((""));

    TXmlEngElement software = NcdProtocolUtils::NewElementL( aDocument, 

        KTagSoftware, aPrefix );

    // software/@version, required

    NcdProtocolUtils::NewAttributeL(software, KAttrVersion, iSoftware.version);

    NcdProtocolUtils::NewAttributeL(software, KAttrType, iSoftware.type);

    if (iSoftware.uid.NotNull())

        NcdProtocolUtils::NewAttributeL(software, KAttrUid, iSoftware.uid);

    if (iSoftware.id.NotNull())

        NcdProtocolUtils::NewAttributeL(software, KAttrId, iSoftware.id);

    if (iSoftware.ssid.NotNull())

        NcdProtocolUtils::NewAttributeL(software, KAttrSsid, iSoftware.ssid);

    if ( iSoftware.language.NotNull() ) 

        {

        TXmlEngElement language = NcdProtocolUtils::NewElementL( aDocument, 

            software, KTagLanguage, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        language.SetTextL( iSoftware.language );

#else

        language.SetTextL( iSoftware.language.PtrC8() );

#endif

        }

    if ( iSoftware.capabilities.Count() > 0 ) 

        {

        TXmlEngElement capabilities = NcdProtocolUtils::NewElementL( 

            aDocument, software, KTagCapabilities, aPrefix );

        for (TInt i = 0; i < iSoftware.capabilities.Count(); ++i)

            {            

            TXmlEngElement capability = NcdProtocolUtils::NewElementL( 

                aDocument, capabilities, KTagCapability, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE            

            capability.SetTextL( iSoftware.capabilities[i] );            

#else

            capability.SetTextL( iSoftware.capabilities[i].PtrC8() );

#endif            

            }

        }

    // details

    if ( iSoftware.details.Count() > 0 ) 

        {

        TXmlEngElement details = 

            NcdProtocolUtils::NewElementL( aDocument, software, 

                KTagDetails, aPrefix );

        for ( TInt i = 0; i < iSoftware.details.Count(); ++i ) 

            {

            MNcdConfigurationProtocolDetail* det = iSoftware.details[i];

            details.AppendChildL( GetDetailsElementL( aDocument, 

                *det, aPrefix ) );

            }

        }

    DLTRACEOUT((""));

    return software;

    }

/**

 * Hardware-element for client-elements

 */

CNcdRequestConfigurationHardware* CNcdRequestConfigurationHardware::NewL()

    {

    CNcdRequestConfigurationHardware* self = new(ELeave) 

        CNcdRequestConfigurationHardware;

    return self;

    }

CNcdRequestConfigurationHardware::~CNcdRequestConfigurationHardware()

    {

    // Clean iHardware

    iHardware.uaProfileUri.Free();

    iHardware.identification.Free();

    iHardware.manufacturer.Free();

    iHardware.model.Free();

    iHardware.language.Free();

    iHardware.platform.Free();

    iHardware.firmwareVersion.Free();

    iHardware.displays.ResetAndDestroy();

    iHardware.details.ResetAndDestroy();

    }

void CNcdRequestConfigurationHardware::SetHardwareUaProfileUriL( 

    const TDesC& aUaProfileUri )

    {

    iHardware.uaProfileUri.SetL(aUaProfileUri);

    }

void CNcdRequestConfigurationHardware::SetHardwareIdentificationL( 

    const TDesC& aIdentification )

    {

    iHardware.identification.SetL(aIdentification);

    }

void CNcdRequestConfigurationHardware::SetHardwareManufacturerL( 

    const TDesC& aManufacturer )

    {

    iHardware.manufacturer.SetL(aManufacturer);

    }

void CNcdRequestConfigurationHardware::SetHardwareModelL( 

    const TDesC& aModel )

    {

    iHardware.model.SetL(aModel);

    }

void CNcdRequestConfigurationHardware::SetHardwareLanguageL( 

    const TDesC& aLanguage )

    {

    iHardware.language.SetL(aLanguage);

    }

void CNcdRequestConfigurationHardware::SetHardwarePlatformL( 

    const TDesC& aPlatform )

    {

    iHardware.platform.SetL(aPlatform);

    }

void CNcdRequestConfigurationHardware::SetHardwareFirmwareL( 

    const TDesC& aFirmwareVersion )

    {

    iHardware.firmwareVersion.SetL(aFirmwareVersion);

    }

void CNcdRequestConfigurationHardware::AddHardwareDisplayL( 

    TInt aColors, TInt aHeight, TInt aWidth )

    {

    CNcdConfigurationDisplay* disp = new (ELeave) CNcdConfigurationDisplay;

    disp->iColors = aColors;

    disp->iHeight = aHeight;

    disp->iWidth = aWidth;

    if ( iHardware.displays.Append(disp) != KErrNone ) 

        {

        delete disp;

        }

    }

void CNcdRequestConfigurationHardware::AddHardwareDetailsL( 

    MNcdConfigurationProtocolDetail* aDetail )

    {

    iHardware.details.AppendL(aDetail);

    }

TXmlEngElement CNcdRequestConfigurationHardware::GetHardwareConfigurationElementL(

    RXmlEngDocument& aDocument, const TXmlEngString& aPrefix )

    {

    DLTRACEIN((""));

    TXmlEngElement hardware = NcdProtocolUtils::NewElementL( aDocument, 

        KTagHardware, aPrefix );

    if (iHardware.uaProfileUri.NotNull()) 

        {

        TXmlEngElement uaProfileUri = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagUaProfileUri, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        uaProfileUri.SetTextL(iHardware.uaProfileUri);

#else

        uaProfileUri.SetTextL( iHardware.uaProfileUri.PtrC8() );

#endif

        }

    if (iHardware.identification.NotNull())

        {

        TXmlEngElement identification = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagIdentification, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        identification.SetTextL(iHardware.identification);

#else

        identification.SetTextL( iHardware.identification.PtrC8() );

#endif

        }

    if (iHardware.manufacturer.NotNull())

        {

        TXmlEngElement manufacturer = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagManufacturer, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        manufacturer.SetTextL(iHardware.manufacturer);

#else

        manufacturer.SetTextL( iHardware.manufacturer.PtrC8() );

#endif

        }

    if (iHardware.model.NotNull())

        {

        TXmlEngElement model = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagModel, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        model.SetTextL(iHardware.model);

#else

        model.SetTextL( iHardware.model.PtrC8() );

#endif

        }

    if (iHardware.language.NotNull())

        {

        TXmlEngElement language = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagLanguage, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        language.SetTextL(iHardware.language);

#else

        language.SetTextL( iHardware.language.PtrC8() );

#endif

        }

    if (iHardware.platform.NotNull())

        {

        TXmlEngElement platform = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagPlatform, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        platform.SetTextL(iHardware.platform);

#else

        platform.SetTextL( iHardware.platform.PtrC8() );

#endif

        }

    if (iHardware.firmwareVersion.NotNull())

        {

        TXmlEngElement firmwareVersion = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagFirmwareVersion, aPrefix );

#ifndef RD_XML_ENGINE_API_CHANGE

        firmwareVersion.SetTextL(iHardware.firmwareVersion);

#else

        firmwareVersion.SetTextL( iHardware.firmwareVersion.PtrC8() );

#endif

        }

    for (TInt i = 0; i < iHardware.displays.Count(); ++i)

        {

        CNcdConfigurationDisplay* disp = iHardware.displays[i];

        TXmlEngElement display = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagDisplay, aPrefix );

        NcdProtocolUtils::NewAttributeL( display, KAttrWidth, disp->iWidth );

        NcdProtocolUtils::NewAttributeL( display, KAttrHeight, disp->iHeight );

        NcdProtocolUtils::NewAttributeL( display, KAttrColors, disp->iColors );

        }

    // details

    if ( iHardware.details.Count() > 0 ) 

        {

        TXmlEngElement details = NcdProtocolUtils::NewElementL( 

            aDocument, hardware, KTagDetails, aPrefix );

        for ( TInt i = 0; i < iHardware.details.Count(); ++i ) 

            {

            MNcdConfigurationProtocolDetail* det = iHardware.details[i];

            details.AppendChildL( GetDetailsElementL( aDocument, 

                *det, aPrefix ) );

            }

        }

    if (hardware.HasChildNodes())

        {

        DLTRACEOUT((""));

        return hardware;        

        }

    DLTRACEOUT(("return null"));

    return NULL;        

    }

/**

 * Client-element for configuration requests

 */

CNcdRequestConfigurationClient* CNcdRequestConfigurationClient::NewLC()

    {

    CNcdRequestConfigurationClient* self = new(ELeave) 

        CNcdRequestConfigurationClient;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CNcdRequestConfigurationClient::~CNcdRequestConfigurationClient()

    {

    iSoftwares.ResetAndDestroy();

    delete iHardware;

    }

void CNcdRequestConfigurationClient::AddSoftwareL( 

    CNcdRequestConfigurationSoftware* aSoftware )

    {

    iSoftwares.AppendL( aSoftware );

    }

TInt CNcdRequestConfigurationClient::SoftwareCount() const

    {

    return iSoftwares.Count();

    }

CNcdRequestConfigurationSoftware& 

    CNcdRequestConfigurationClient::Software( TInt aIndex )

    {

    return *(iSoftwares[ aIndex ]);

    }

CNcdRequestConfigurationHardware& CNcdRequestConfigurationClient::Hardware()

    {

    DASSERT( iHardware );

    return *iHardware;

    }

CNcdRequestConfigurationClient::CNcdRequestConfigurationClient()

    {

    }

void CNcdRequestConfigurationClient::ConstructL()

    {

    iHardware = CNcdRequestConfigurationHardware::NewL();

    }

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

// CNcdRequestConfigurationData

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

//

CNcdRequestConfigurationData* CNcdRequestConfigurationData::NewLC()

    {

    CNcdRequestConfigurationData* self = 

        new (ELeave) CNcdRequestConfigurationData();

    CleanupStack::PushL(self);