/*

* Copyright (c) 2007-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 "ncdsendhttprequestoperationimpl.h"

#include <s32mem.h>

#include <apmstd.h>

#include "catalogsbasemessage.h"

#include "catalogshttpincludes.h"

#include "catalogsutils.h"

#include "catalogscontext.h"

#include "ncdproviderdefines.h"

#include "catalogshttprequestadapter.h"

#include "catalogshttpresponsecomposer.h"

#include "ncdproviderutils.h"

#include "ncdhttputils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

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

// NewL

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

//

CNcdSendHttpRequestOperation* CNcdSendHttpRequestOperation::NewL( 

    HBufC8* aUri,

    HBufC8* aRequest,        

    const TNcdConnectionMethod& aMethod,

    CNcdGeneralManager& aGeneralManager,

    MNcdOperationRemoveHandler& aRemoveHandler, 

    MCatalogsHttpSession& aHttpSession,

    MCatalogsSession& aSession )

    {

    CNcdSendHttpRequestOperation* self = new( ELeave ) CNcdSendHttpRequestOperation(      

        aGeneralManager,

        aRemoveHandler, 

        aHttpSession,

        aSession );

    CleanupClosePushL( *self );

    self->ConstructL( aMethod, aUri, aRequest );

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CNcdSendHttpRequestOperation::~CNcdSendHttpRequestOperation()

    {

    DLTRACEIN( ( "" ) );    

    if ( iTransaction ) 

        {

        iTransaction->Release();

        iTransaction = NULL;

        }

    delete iUri;

    delete iRequest;

    delete iResponse;

    delete iAdapter;

    delete iBody;

    }

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

// HTTP event handler

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

//

void CNcdSendHttpRequestOperation::HandleHttpEventL( 

    MCatalogsHttpOperation& aOperation, 

    TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN((""));

    if ( aEvent.iOperationState == ECatalogsHttpOpInProgress &&

         aEvent.iProgressState == ECatalogsHttpResponseBodyReceived ) 

        {

        // Append the body

        iBody->InsertL( iBody->Size(), aOperation.Body() );

        }

    else if ( aEvent.iOperationState == ECatalogsHttpOpCompleted ) 

        {

        DLTRACE(("Operation complete"));

        // Compose the response here

        TCatalogsHttpResponseComposer composer;

        iResponse = composer.ComposeResponseL( 

            aOperation, 

            iBody->Ptr( 0 ) );

        delete iBody;

        iBody = NULL;

        aOperation.Release();

        iTransaction = NULL;

        iOperationState = EStateComplete;

        RunOperation();

        }

    }

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

// HTTP error handler

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

//

TBool CNcdSendHttpRequestOperation::HandleHttpError(

    MCatalogsHttpOperation& aOperation,

    TCatalogsHttpError aError )

    {

    DLTRACEIN((""));

    aOperation.Cancel();

    iTransaction = NULL;

    iError = aError.iError;

    iOperationState = EStateComplete;

    RunOperation();

    return ETrue;

    }

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

// Cancel

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

//

void CNcdSendHttpRequestOperation::Cancel() 

    {    

    DLTRACEIN(( "" ));

    if ( iTransaction ) 

        {

        iTransaction->Cancel();

        iTransaction = NULL;

        }

    }

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

// ReceiveMessage

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

//

void CNcdSendHttpRequestOperation::ReceiveMessage( 

    MCatalogsBaseMessage* aMessage,

    TInt aFunctionNumber )

    {

    DLTRACEIN(( "Function: %d", aFunctionNumber ));

    TInt err = KErrNone;

    // Response to pause and resume messages, other messages are handled

    // by the base class

    switch ( aFunctionNumber )

        {

        case ENCDOperationFunctionGetData: 

            {

            DLTRACE(( "ENCDOperationFunctionGetData "));

            // Only error will come from CompleteMessageL

            TRAP( err, GetResponseL( *aMessage ) );

            break;

            }

        default:

            {

            DLTRACE(("Calling baseclass"));

            // Call implementation in the base class

            CNcdBaseOperation::ReceiveMessage( aMessage, aFunctionNumber );

            DLTRACEOUT(( "Called baseclass" ));

            return;

            }

        }                    

    HandleError( err );

    DLTRACEOUT(( "" ));

    }

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

// RunOperation

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

//

TInt CNcdSendHttpRequestOperation::RunOperation()

    {

    DLTRACEIN(( "Pending message: %X", iPendingMessage ));

    if ( !iPendingMessage ) 

        {      

        DLTRACE(("No pending message"));  

        return KErrNotReady;

        }

    TRAPD( err, HandleStateL() );

    HandleError( err );

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

    return err;

    }

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

// 

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

//

void CNcdSendHttpRequestOperation::HandleStateL()

    {

    switch ( iOperationState ) 

        {

        case EStateRunning: 

            {

            DLTRACE(("Creating request"));

            DASSERT( iRequest );            

            iTransaction = iAdapter->CreateTransactionL( 

                *iUri,

                *iRequest,

                *this );

            iTransaction->Config().SetConnectionMethod( 

                iConnectionMethod );

            TInt err = iTransaction->Start();

            if ( err != KErrNone ) 

                {

                DLERROR(("Start failed with %d", err));

                iTransaction->Cancel();

                iTransaction = NULL;

                User::Leave( err );

                }

            break;

            }

        case EStateComplete:

            {

            // Returns false if there was no error

            if ( !HandleError( iError ) ) 

                {

                DLTRACE(("Completing the operation"));                

                CNcdBaseOperation::CompleteMessage( 

                    iPendingMessage,

                    ENCDOperationMessageCompletionComplete, 

                    iProgress,

                    KErrNone );

                }

            break;

            }

        default: 

            {

            DASSERT( 0 );

            }

        }

    }

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

// 

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

//

TBool CNcdSendHttpRequestOperation::HandleError( TInt aError ) 

    {

    DLTRACEIN(("aError: %d", aError ));

    if ( aError != KErrNone ) 

        {

        DLERROR(("Error %d occurred", aError ));

        iError = aError;

        iOperationState = EStateCancelled;

        Cancel();

        if ( iPendingMessage )

            {

            // ignoring error because operation already failed

            CNcdBaseOperation::CompleteMessage( iPendingMessage,

                ENCDOperationMessageCompletionError, iError );

            }

        return ETrue;

        }    

    return EFalse;

    }

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

// 

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

//    

void CNcdSendHttpRequestOperation::GetResponseL( 

    MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    if ( !iResponse ) 

        {

        User::Leave( KErrCorrupt );

        }

    aMessage.CompleteAndReleaseL(

        *iResponse, 

        KErrNone );

    }

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

// Constructor

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

//

CNcdSendHttpRequestOperation::CNcdSendHttpRequestOperation(

    CNcdGeneralManager& aGeneralManager,

    MNcdOperationRemoveHandler& aRemoveHandler,

    MCatalogsHttpSession& aHttpSession,

    MCatalogsSession& aSession )

    :

    CNcdBaseOperation( aGeneralManager, &aRemoveHandler, ESendHttpRequestOperation,

        aSession ), 

    iHttpSession( aHttpSession )

    {

    }

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

// ConstructL

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

//

void CNcdSendHttpRequestOperation::ConstructL(

    const TNcdConnectionMethod& aMethod,

    HBufC8* aUri,

    HBufC8* aRequest )

    {

    DLTRACEIN( ( "" ) );

    // Call ConstructL for the base class

    CNcdBaseOperation::ConstructL();

    iAdapter = CCatalogsHttpRequestAdapter::NewL( iHttpSession );

    iBody = CBufFlat::NewL( NcdProviderDefines::KNcdBufferExpandSize );

    iGeneralManager.HttpUtils().ConvertConnectionMethod( 

        aMethod,

        iConnectionMethod );

    iUri = aUri;

    iRequest = aRequest;

    }