/*

* Copyright (c) 2003 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: Http Transaction class for Imps.

*

*

*/

// INCLUDE FILES

#include <hal.h>

#include "ImpsHttpTransaction.h"

#include "HttpTransportAdapter.h"

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

//

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

// CImpsHttpTransaction::CImpsHttpTransaction

//

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

//

CImpsHttpTransaction::CImpsHttpTransaction( CHttpTransportAdapter* aTransportAdapter,

                                            const TInt aTID ) :

        iTransportAdapter( aTransportAdapter ),

        iTID( aTID ),

        iSent( EFalse ),

        iCancelled( EFalse ),

        iConstructed( EFalse )

    {

    }

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

// CImpsHttpTransaction::NewL

//

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

//

CImpsHttpTransaction* CImpsHttpTransaction::NewL( CHttpTransportAdapter* aTransportAdapter,

                                                  const TInt aTID,

                                                  const TDesC8& aRequestBody )

    {

    CImpsHttpTransaction* self = new ( ELeave ) CImpsHttpTransaction( aTransportAdapter, aTID );

    CleanupStack::PushL( self );

    self->ConstructL( aRequestBody );

    CleanupStack::Pop();

    return self;

    }

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

// CImpsHttpTransaction::ConstructL

//

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

//

void CImpsHttpTransaction::ConstructL( const TDesC8& aRequestBody )

    {

    ConstructRequestL();

    CopyRequestDataL( aRequestBody );

    iResponseData = CBufSeg::NewL( 500 );

    }

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

// CImpsHttpTransaction::ConstructRequestL

//

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

//

void CImpsHttpTransaction::ConstructRequestL()

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "CImpsHttpTransaction::ConstructRequestL()" ) );

#endif

    RHTTPSession session = iTransportAdapter->HttpSession();

    RStringF method = session.StringPool().OpenFStringL( K8BitRequestPost );

    CleanupClosePushL( method );

    iHttpTransaction = session.OpenTransactionL( iTransportAdapter->DefaultSAP(), *iTransportAdapter, method );

    iConstructed = ETrue;

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "HTTP-ID: %d TID: %d constructed." ), iHttpTransaction.Id(), iTID );

#endif

    RStringF contTypeStr = session.StringPool().OpenFStringL( iTransportAdapter->MimeType() );

    CleanupClosePushL( contTypeStr );

    RHTTPHeaders hdr = iHttpTransaction.Request().GetHeaderCollection();

    THTTPHdrVal contType( contTypeStr );

    hdr.SetFieldL( session.StringPool().StringF( HTTP::EContentType, RHTTPSession::GetTable() ), contType );

    //This transaction supplies the stack with the payload data.

    iHttpTransaction.Request().SetBody( *this );

    CleanupStack::PopAndDestroy( 2 );  //contTypeStr, method

    }

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

// CImpsHttpTransaction::~CImpsHttpTransaction

//

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

//

CImpsHttpTransaction::~CImpsHttpTransaction()

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "CImpsHttpTransaction::~CImpsHttpTransaction(). Destructor called. TID: %d" ), iTID );

#endif

    delete iRequestData;

    delete iResponseData;

    delete iExpiryTimer;

    if ( iConstructed && !iTransportAdapter->SessionClosed() )

        {

#ifdef _DEBUG

        CHttpTransportAdapter::WriteToLog( _L8( "HTTP-ID: %d TID: %d destructed." ), iHttpTransaction.Id(), iTID );

#endif

        iHttpTransaction.Close();

        }

    }

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

// CImpsHttpTransaction::GetNextDataPart

//

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

//

TBool CImpsHttpTransaction::GetNextDataPart( TPtrC8& aDataPart )

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L( "CImpsHttpTransaction::GetNextDataPart(), iTID: %d" ), iTID );

#endif

    aDataPart.Set( iRequestData->Des() );

    return ETrue;

    }

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

// CImpsHttpTransaction::DispatchMessageL

//

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

//

void CImpsHttpTransaction::DispatchMessageL()

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L( "CImpsHttpTransaction::DispatchMessageL(), iTID: %d" ), iTID );

    iSendTime = TimeL();

#endif

    iHttpTransaction.SubmitL();

    SetStatus( ETrue );

    }

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

// CImpsHttpTransaction::AppendDataL

//

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

//

void CImpsHttpTransaction::AppendDataL( const TPtrC8& aBodyPart,

                                        const TBool aLastChunk )

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "CImpsHttpTransaction::AppendDataL() - Length of the chunk: %d" ), aBodyPart.Length() );

#endif

    iLastChunk = aLastChunk;

    iResponseData->ResizeL( iCurrentDataLength + aBodyPart.Length() );

    iResponseData->Write( iCurrentDataLength, aBodyPart );

    iCurrentDataLength = iCurrentDataLength + aBodyPart.Length();

    }

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

// CImpsHttpTransaction::FinaliseRequestL

//

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

//

void CImpsHttpTransaction::FinaliseRequestL( const TInt aErrorCode )

    {

    TInt dataLength = iResponseData->Size();

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "CImpsHttpTransaction::FinaliseRequestL() TID: %d" ), iTID );

    CHttpTransportAdapter::WriteToLog( _L8( "  Content-Length: %d" ), iContentLength );

    CHttpTransportAdapter::WriteToLog( _L8( "  Actual length: %d" ), dataLength );

    if ( iContentLength >= 0 && iContentLength < KMaxTInt )

        {

        if ( iContentLength == dataLength )

            CHttpTransportAdapter::WriteToLog( _L8( "  Correct" ) );

        else

            CHttpTransportAdapter::WriteToLog( _L8( "  Actual length and the value of Content-Length header do not match!" ) );

        }

#endif

    if ( dataLength > 0 )

        {

#ifdef _DEBUG

        CHttpTransportAdapter::WriteToLog( _L8( "  Gather data & complete the request" ) );

#endif

        //CleanupStack is not used here, since there are no leaving methods

        //before the ownership of the allocated data is transferred in the

        //TransportResponse() method call on client's side

        HBufC8* wholeData = HBufC8::NewL( dataLength );

        TPtr8 pointer( wholeData->Des() );

        iResponseData->Read( 0, pointer, dataLength );

        iResponseData->Reset();

        iCurrentDataLength = 0;

        iTransportAdapter->ReceiverHandle().TransportResponse( iTID, aErrorCode,

                                                               HttpStatus(), wholeData );

        //So - let's hope the guys on the other side remember

        //to release the data...!?

        }

    else

        {

#ifdef _DEBUG

        CHttpTransportAdapter::WriteToLog( _L8( "  No data for this transaction" ), dataLength );

#endif

        iTransportAdapter->ReceiverHandle().TransportResponse( iTID, aErrorCode,

                                                               HttpStatus(), NULL );

        }

    }

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

// CImpsHttpTransaction::ReleaseData

//

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

//

void CImpsHttpTransaction::ReleaseData()

    {

    /* Not just yet... We MAY want to resend the data.

    iRequestData->Des().Zero();*/

    }

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

// CImpsHttpTransaction::DoReleaseData

//

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

//

void CImpsHttpTransaction::DoReleaseData()

    {

    //Response has arrived, the request data can be deleted now.

    delete iRequestData;

    iRequestData = NULL;

    }

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

// CImpsHttpTransaction::ResendL

//

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

//

TBool CImpsHttpTransaction::ResendL()

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L( "CImpsHttpTransaction::ResendL(), iTID: %d" ), iTID );

#endif

    if ( iNumberOfRetries < KMaxNumberOfRetries )

        {

        //Close the old transaction

        iHttpTransaction.Close();

        iConstructed = EFalse;

        //Create a new one and send it to the stack.

        ConstructRequestL();

        DispatchMessageL();

#ifdef _DEBUG

        CHttpTransportAdapter::WriteToLog( _L( "  Transaction %d retransmitted." ), iTID );

#endif

        return ETrue;

        }

    else return EFalse;

    }

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

// CImpsHttpTransaction::SetStatus

//

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

//

void CImpsHttpTransaction::SetStatus( const TBool aSent )

    {

    iSent = aSent;

    if ( iSent )

        {

        if ( iExpiryTimer != NULL && !iExpiryTimer->IsActive() )

            iExpiryTimer->ActivateTimer( iExpiryTime );

        }

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L8( "CImpsHttpTransaction::SetStatus(): Status %d, TID: %d" ), iSent, iTID );

#endif

    }

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

// CImpsHttpTransaction::SetStatus

//

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

//

const TInt CImpsHttpTransaction::HttpStatus() const

    {

    return iHttpTransaction.Response().StatusCode();

    }

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

// CImpsHttpTransaction::SetExpiryTimeL

//

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

//

void CImpsHttpTransaction::SetExpiryTimeL( const TTimeIntervalMicroSeconds32 aExpiryTime,

                                           MImpsTransportTimerCallback* aCallback )

    {

    if ( iExpiryTimer == NULL )

        iExpiryTimer = CImpsTransportTimer::NewL( aCallback, this );

    iExpiryTime = aExpiryTime;

    }

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

// CImpsHttpTransaction::CopyRequestData

//

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

//

void CImpsHttpTransaction::CopyRequestDataL( const TDesC8& aRequestData )

    {

#ifdef _DEBUG

    CHttpTransportAdapter::WriteToLog( _L( "CImpsHttpTransaction::CopyRequestDataL()" ) );

#endif

    delete iRequestData;

    iRequestData = NULL;

    iRequestData = HBufC8::NewL( aRequestData.Length() );

    iRequestData->Des().Copy( aRequestData );

    }

#ifdef _DEBUG

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

// CHttpTestAppView::ConstructL

//

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

//

TInt CImpsHttpTransaction::TimeL() const

    {

    TInt period = 0;

    User::LeaveIfError( HAL::Get( HALData::ESystemTickPeriod, period ) );

    TInt millisecsPerTick = period / 1000;

    return User::TickCount() * millisecsPerTick;

    }

#endif