/*

* Copyright (c) 2006-2008 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 "catalogshttptransaction.h"

#include "catalogshttptransactionmanager.h"

#include "catalogshttpobserver.h"

#include "catalogshttpconfigimpl.h"

#include "catalogskeyvaluepair.h"

#include "catalogshttpheadersimpl.h"

#include "catalogshttpstack.h"

#include "catalogsutils.h"

#include "catalogserrors.h"

#include "catalogshttpconnectionmanager.h"

#include "catalogsconnection.h"

#include "catalogshttputils.h"

#include "catalogsdebug.h"

// HTTP header strings

_LIT8( KHttpContentRangeHeader, "Content-Range" );

_LIT8( KHttpContentLengthHeader, "Content-Length" );

_LIT8( KHttpContentTypeHeader, "Content-Type" );

const TInt KTransactionRetries = 3;

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

TInt CCatalogsHttpTransaction::StartCallBack( TAny* aPtr )

    {

    DLTRACEIN((""));

    CCatalogsHttpTransaction* transaction = 

        static_cast<CCatalogsHttpTransaction*>( aPtr );

    TInt err = transaction->Start();

    if ( err != KErrNone ) 

        {

        transaction->iObserver->HandleHttpError( 

            *transaction, 

            TCatalogsHttpError( 

                ECatalogsHttpErrorGeneral, 

                err ) );            

        }

    return KErrNone;

    }

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

// Creator

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

//	

CCatalogsHttpTransaction* CCatalogsHttpTransaction::NewL( 

    MCatalogsHttpTransactionManager& aOwner, 

    const CCatalogsHttpConfig& aConfig,

    const TCatalogsTransportOperationId& aId,

    TCatalogsHttpTransactionType aType )

    {

    CCatalogsHttpTransaction* self = NewLC( aOwner, aConfig, aId, aType );

    CleanupStack::Pop( self );      

    return self;

    }

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

// Creator

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

//	

CCatalogsHttpTransaction* CCatalogsHttpTransaction::NewLC( 

    MCatalogsHttpTransactionManager& aOwner, 

    const CCatalogsHttpConfig& aConfig,

    const TCatalogsTransportOperationId& aId,

    TCatalogsHttpTransactionType aType )

    {

    CCatalogsHttpTransaction* self = new( ELeave ) CCatalogsHttpTransaction( 

        aOwner, aId, aType );

    CleanupStack::PushL( self );

    self->ConstructL( &aConfig );    

    return self;

    }

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

// Destructor

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

//	

CCatalogsHttpTransaction::~CCatalogsHttpTransaction()

    {    

    DLTRACEIN(( "Deleting Operation: %i, id: %i", 

        reinterpret_cast<TInt>( this ), OperationId().Id() ));

    SetTransferring( EFalse );    

    ReleasePtr( iConnection );

    DLTRACE(( "Removing from owner" ));

    delete iHttp;

    iOwner.RemoveOperation( this ); 

    iOwner.CompleteOperation( this );    

    DLTRACE(( "Deleting config" ));    

    delete iConfig;

    DLTRACE(( "Deleting response headers" ));

    delete iResponseHeaders;    

    DLTRACE(( "Deleting request body" ));

    delete iRequestBody;

    DLTRACE(( "Deleting content type" ));

    delete iContentType;   

    delete iUri;

    delete iEncodedUri;

    delete iResponseStatusText;

    delete iCallBack;

    DLTRACEOUT(( "" ));

    }

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

// Add a reference

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

//

TInt CCatalogsHttpTransaction::AddRef()

    {

    iRefCount++;

    return iRefCount;

    }

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

// Release a reference

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

//

TInt CCatalogsHttpTransaction::Release()

    {

    DLTRACEIN(( "" ));

    iRefCount--;

    if ( !iRefCount ) 

        {

        delete this;

        return 0;

        }

    return iRefCount;

    }

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

// Reference count

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

//        

TInt CCatalogsHttpTransaction::RefCount() const

    {

    return iRefCount;

    }

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

// Cancel transaction

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

//	

TInt CCatalogsHttpTransaction::Cancel()

    {

    DLTRACEIN(( "" )); 

    iState.iOperationState = ECatalogsHttpOpDeleting;

    SetTransferring( EFalse );

    if ( iHttp ) 

        {        

        iHttp->CancelTransaction(); 

        DeletePtr( iHttp );        

        }

    if ( iState.iProgressState != ECatalogsHttpNone && 

         iState.iProgressState != ECatalogsHttpDone ) 

        {        

        iOwner.CompleteOperation( this );

        }

    DLTRACE(("Calling release"));

    return Release();

    }

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

// Transaction progress

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

//	

TCatalogsTransportProgress CCatalogsHttpTransaction::Progress() const

    {

    return TCatalogsTransportProgress( iState.iOperationState, iTransferredLength, 

        iContentLength );

    }

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

// Start download

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

//	

TInt CCatalogsHttpTransaction::Start( TResumeStartInformation /*aResumeOrigin*/ )

    {

    DLTRACEIN(( "" ));    

    if ( !iEncodedUri || !iEncodedUri->Length() ) 

        {

        DLTRACEOUT(( "No URI, return KErrNotReady" ));

        return KErrNotReady;

        }

    DASSERT( iConfig );

    // Update the member variable

    iObserver = iConfig->Observer();

    if ( !iObserver ) 

        {

        DLTRACEOUT(( "iObserver = NULL, return KErrNotReady" ));

        return KErrNotReady;

        }

    TInt err = KErrNone;

    if ( iState.iOperationState == ECatalogsHttpOpCreated 

        || iState.iOperationState == ECatalogsHttpOpQueued )

        {        

        UpdateConfiguration();

        TInt err = iOwner.StartOperation( this );

        if ( err == KErrNone ) 

            {

            TRAP( err, DoStartL() );

            }

        else if ( err == KCatalogsHttpOperationQueued ) 

            {

            DLTRACE(( "Transaction queued" ));

            err = KErrNone;

            // Set as queued and notify observer if any

            iState.iOperationState = ECatalogsHttpOpQueued;            

            if ( iObserver ) 

                {

                // Start errors are returned so no NotifyObserver

                TRAP( err, iObserver->HandleHttpEventL( *this, iState ) );

                }

            }

        }

    DLTRACEOUT(("err: %d", err));

    return err;

    }

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

// Pause download

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

//	

TInt CCatalogsHttpTransaction::Pause()

    {

    DLTRACEIN(( "" ));

    return KErrNotSupported;

    }

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

// 

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

//	

void CCatalogsHttpTransaction::NotifyCancel()

    {

    DLTRACEIN((""));

    if ( iObserver )

        {

        iObserver->HandleHttpError( *this, TCatalogsHttpError(

            ECatalogsHttpErrorGeneral, KErrCancel ) );

        }

    else 

        {

        Cancel();        

        }

    }

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

// Set body

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

//	

void CCatalogsHttpTransaction::SetBodyL( const TDesC8& aBody )

    {

    DLTRACEIN(( "" ));

    delete iRequestBody;

    iRequestBody = NULL;

    iRequestBody = aBody.AllocL();

    }

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

// Set body

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

//	

void CCatalogsHttpTransaction::SetBodyL( const TDesC16& aBody )

    {

    DLTRACEIN(( "" ));

    delete iRequestBody;

    iRequestBody = NULL;

    iRequestBody = ConvertUnicodeToUtf8L( aBody );

    }

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

// Body getter

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

//	

const TDesC8& CCatalogsHttpTransaction::Body() const

    {

    return iResponseBody;

    }

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

// URI setter

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

//	

void CCatalogsHttpTransaction::SetUriL( const TDesC8& aUri )

    {

    delete iUri;

    iUri = NULL;

    iUri = aUri.AllocL();

    EncodeUriL();

    }

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

// URI setter

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

//	

void CCatalogsHttpTransaction::SetUriL( const TDesC16& aUri )

    {

    delete iUri;

    iUri = NULL;

    iUri = ConvertUnicodeToUtf8L( aUri );

    EncodeUriL();    

    }

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

// URI getter

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

//	

const TDesC8& CCatalogsHttpTransaction::Uri() const

    {

    if( iUri ) 

        {        

        return *iUri;

        }

    return KNullDesC8();

    }

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

// Configuration

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

//	

MCatalogsHttpConfig& CCatalogsHttpTransaction::Config() const

    {

    return *iConfig;

    }

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

// Request headers

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

//	

MCatalogsHttpHeaders& CCatalogsHttpTransaction::RequestHeadersL() const

    {

    return iConfig->RequestHeaders();

    }

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

// Response headers

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

//	

const MCatalogsHttpHeaders& CCatalogsHttpTransaction::ResponseHeadersL() const

    {

    return *iResponseHeaders;

    }

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

// Operation type

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

//	

TCatalogsHttpOperationType CCatalogsHttpTransaction::OperationType() const

    {

    return ECatalogsHttpTransaction;    

    }

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

// Operation ID

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

//	

const TCatalogsTransportOperationId& 

    CCatalogsHttpTransaction::OperationId() const

    {

    return iId;

    }

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

// Content type setter

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

//	

void CCatalogsHttpTransaction::SetContentTypeL( const TDesC8& aContentType )

    {

    delete iContentType;

    iContentType = NULL;

    iContentType = aContentType.AllocL();

    }

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

// Content type setter

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

//	

void CCatalogsHttpTransaction::SetContentTypeL( const TDesC16& aContentType )

    {

    delete iContentType;

    iContentType = NULL;

    iContentType = ConvertUnicodeToUtf8L( aContentType );

    }

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

// Content type getter

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

//	

const TDesC8& CCatalogsHttpTransaction::ContentType() const

    {

    if ( iContentType )

        {

        return *iContentType;

        }

    return KNullDesC8();

    }

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

// Content size getter

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

//	

TInt32 CCatalogsHttpTransaction::ContentSize() const

    { 

    return iContentLength;

    }

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

// Downloaded size getter

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

//	

TInt32 CCatalogsHttpTransaction::TransferredSize() const

    {

    return iTransferredLength;

    }

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

// Is download pausable

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

//	

TBool CCatalogsHttpTransaction::IsPausable() const

    {

    return EFalse;

    }

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

// Sets header mode

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

//	

void CCatalogsHttpTransaction::SetHeaderMode( TCatalogsHttpHeaderMode 

    /*aMode*/ )

    {

    // not supported

    }

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

// Transaction status code

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

//	

TInt CCatalogsHttpTransaction::StatusCode() const

    {

    return iResponseStatusCode;

    }

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

// Transaction status text

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

//	

const TDesC8& CCatalogsHttpTransaction::StatusText() const

    {

    if ( iResponseStatusText ) 

        {

        return *iResponseStatusText;