/*

* 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:  

*

*/

#include <e32cmn.h>

#include <s32strm.h>

#include "catalogshttpconfigimpl.h"

#include "catalogskeyvaluepair.h"

#include "catalogshttpobserver.h"

#include "catalogshttpheadersimpl.h"

#include "catalogshttpconfigobserver.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

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

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

// Creator

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

//	

CCatalogsHttpConfig* CCatalogsHttpConfig::NewL( 

    MCatalogsHttpConfigObserver* aObserver)

    {

    CCatalogsHttpConfig* self = new ( ELeave ) CCatalogsHttpConfig( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Creator

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

//	

CCatalogsHttpConfig* CCatalogsHttpConfig::NewL( 

    RReadStream& aStream,

    MCatalogsHttpConfigObserver* aObserver)

    {

    CCatalogsHttpConfig* self = new ( ELeave ) CCatalogsHttpConfig( 

        aObserver );

    CleanupStack::PushL( self );    

    self->InternalizeL( aStream );

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//	

CCatalogsHttpConfig::~CCatalogsHttpConfig()

    {    

    delete iFilename;    

    delete iDirectory;

    // Delete headers

    delete iHeaders;   

    }

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

// Priority setter

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

//	

void CCatalogsHttpConfig::SetPriority( TCatalogsTransportPriority aPriority )

    {

    if ( aPriority != iPriority ) 

        {        

        iPriority = aPriority;

        // Notify the operation of a priority change

        if ( iOwnObserver ) 

            {            

            iOwnObserver->HandleHttpConfigEvent( this, 

                ECatalogsHttpCfgPriorityChanged );

            }

        }

    }

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

// Priority getter

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

//	

TCatalogsTransportPriority CCatalogsHttpConfig::Priority() const

    {

    return iPriority;

    }

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

// Directory path setter

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

//	

void CCatalogsHttpConfig::SetDirectoryL( const TDesC& aDirectory )

    {

    if( aDirectory.Length() )

        {

        HBufC* temp = aDirectory.AllocL();

        delete iDirectory;

        iDirectory = NULL;

        iDirectory = temp;

        }

    else 

        {

        delete iDirectory;

        iDirectory = NULL;

        }        

    }

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

// Directory path getter

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

//	

const TDesC& CCatalogsHttpConfig::Directory() const

    {

    if( iDirectory ) 

        {

        return *iDirectory;

        }

    return KNullDesC();

    }

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

// Filename setter

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

//	

void CCatalogsHttpConfig::SetFilenameL( const TDesC& aFilename )

    {

    if( aFilename.Length() ) 

        {

        HBufC* temp = aFilename.AllocL();

        delete iFilename;

        iFilename = NULL;

        iFilename = temp;

        }

    else 

        {

        // aFilename is empty so we delete the old filename

        delete iFilename;

        iFilename = NULL;

        }

    }

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

// Filename getter

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

//	

const TDesC& CCatalogsHttpConfig::Filename() const

    {

    if( iFilename ) 

        {

        return *iFilename;

        }

    return KNullDesC();

    }

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

// Full path

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

//	

HBufC* CCatalogsHttpConfig::FullPathLC() const    

    {

    DLTRACEIN((""));

    if ( iDirectory == NULL

         || iDirectory->Length() == 0

         || iFilename == NULL

         || iFilename->Length() == 0 )

        {

        // Directory and filename should always be set.

        // NULL or empty values are not accepted.

        User::Leave( KErrPathNotFound );

        }

    HBufC* fullpath = HBufC::NewLC( iDirectory->Length() 

        + iFilename->Length() );

    TPtr ptr( fullpath->Des() );

    ptr.Append( *iDirectory );

    ptr.Append( *iFilename );

    DLTRACEOUT(( _L("Path: %S"), fullpath ));

    return fullpath;

    }

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

// Headers getter

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

//	

MCatalogsHttpHeaders& CCatalogsHttpConfig::RequestHeaders() const

    {

    return *iHeaders;

    }

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

// Accesspoint setter

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

//	

void CCatalogsHttpConfig::SetConnectionMethod( 

    const TCatalogsConnectionMethod& aMethod )

    {

    iConnectionMethod = aMethod;

    }

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

// Access point getter

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

//	

const TCatalogsConnectionMethod& CCatalogsHttpConfig::ConnectionMethod() const

    {

    return iConnectionMethod;

    }

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

// Observer setter

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

//	

void CCatalogsHttpConfig::SetObserver( MCatalogsHttpObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// Observer getter

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

//	

MCatalogsHttpObserver* CCatalogsHttpConfig::Observer() const

    {

    return iObserver;

    }

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

// Set HTTP method

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

//	

void CCatalogsHttpConfig::SetHttpMethod( TCatalogsHttpMethod aMethod )

    {

    iHttpMethod = aMethod;    

    }

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

// Get HTTP method

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

//	

TCatalogsHttpMethod CCatalogsHttpConfig::HttpMethod() const

    {

    return iHttpMethod;

    }

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

// Externalize

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

//	

void CCatalogsHttpConfig::ExternalizeL( RWriteStream& aStream ) const

    {

    DLTRACEIN((""));

    aStream.WriteInt32L( iPriority );

    ExternalizeDesL( Directory(), aStream );

    ExternalizeDesL( Filename(), aStream );

    iHeaders->ExternalizeL( aStream );

    iConnectionMethod.ExternalizeL( aStream );    

    aStream.WriteInt32L( iHttpMethod );

    aStream.WriteUint32L( iOptions );

    }

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

// Internalize

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

//	

void CCatalogsHttpConfig::InternalizeL( RReadStream& aStream )

    {

    DLTRACEIN((""));

    iPriority = static_cast<TCatalogsTransportPriority>( 

        aStream.ReadInt32L() );

    InternalizeDesL( iDirectory, aStream );

    InternalizeDesL( iFilename, aStream );

    delete iHeaders;

    iHeaders = NULL;

    iHeaders = CCatalogsHttpHeaders::NewL( aStream );

    iConnectionMethod.InternalizeL( aStream );

    iHttpMethod = static_cast<TCatalogsHttpMethod>( aStream.ReadInt32L() );

    iOptions = aStream.ReadUint32L();

    }

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

// Options getter

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

//  

TUint32 CCatalogsHttpConfig::Options() const

    {

    return iOptions;

    }

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

// Options setter

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

//  

void CCatalogsHttpConfig::SetOptions( TUint32 aOptions )

    {

    iOptions = aOptions;

    }

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

// Cloner

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

//	

CCatalogsHttpConfig* CCatalogsHttpConfig::CloneL() const

    {

    CCatalogsHttpConfig* copy = new( ELeave ) CCatalogsHttpConfig( *this );

    CleanupStack::PushL( copy );

    copy->ConstructL( *this );

    CleanupStack::Pop( copy );

    return copy;

    }

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

// Constructor

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

//	

CCatalogsHttpConfig::CCatalogsHttpConfig( MCatalogsHttpConfigObserver* aObserver ) : 

    iOwnObserver( aObserver ), iPriority( ECatalogsPriorityMedium ), 

    iHttpMethod( ECatalogsHttpPost )    

    {

    }

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

// 2nd phase constructor

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

//	

void CCatalogsHttpConfig::ConstructL()

    {

    iHeaders = CCatalogsHttpHeaders::NewL();

    iFilename = KNullDesC().AllocL();

    iDirectory = KNullDesC().AllocL();

    }

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

// Copy constructor

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

//	

CCatalogsHttpConfig::CCatalogsHttpConfig( const CCatalogsHttpConfig& aOther ): 

    iOwnObserver( aOther.iOwnObserver ),

    iPriority( aOther.iPriority ), 

    iConnectionMethod( aOther.iConnectionMethod ), 

    iObserver( aOther.iObserver ), 

    iHttpMethod ( aOther.iHttpMethod ),

    iOptions( aOther.iOptions )

    {

    }

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

// 2nd phase of copy construction

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

//	

void CCatalogsHttpConfig::ConstructL( const CCatalogsHttpConfig& aOther )

    {

    iFilename = aOther.Filename().AllocL();        

    iDirectory = aOther.Directory().AllocL();

    // Copy headers

    iHeaders = aOther.iHeaders->CloneL();    

    }