/*

* Copyright (c) 2002 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:  Container of the one outgoing transaction handler

*				  It process one handler until it is completed

* 				  canceled or some error ocures.

* 				  Its completion is signaled to the observer

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    "CPEngOutGoingTransContainer.h"

#include    "MPEngOutgoingTransactionHandler.h"

#include    "MPEngPureDataHandler.h"

#include	"MPEngHandlerSendData.h"

//	Debug prints

#include	"PresenceDebugPrint.h"

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

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

// CPEngOutGoingTransContainer::CPEngOutGoingTransContainer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPEngOutGoingTransContainer::CPEngOutGoingTransContainer(

    MPEngHandlerSendData& aRequestHandler,

    MPEngPureDataHandler& aPureDataHandler,

    RPointerArray<MPEngOutgoingTransactionHandler>&

    aTransactionHandlersArray )

        : CActive( CActive::EPriorityStandard ),

        iPureDataHandler( aPureDataHandler ),

        iRequestHandler( aRequestHandler ),

        iNewTransactionHandlers( aTransactionHandlersArray )

    {

    }

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

// CPEngOutGoingTransContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngOutGoingTransContainer::ConstructL()

    {

    // add active object to the active scheduler

    CActiveScheduler::Add( this );

    }

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

// CPEngOutGoingTransContainer::NewL

// Two-phased constructor.

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

//

CPEngOutGoingTransContainer* CPEngOutGoingTransContainer::NewL(

    MPEngHandlerSendData& aRequestHandler,

    MPEngPureDataHandler& aPureDataHandler,

    RPointerArray<MPEngOutgoingTransactionHandler>&

    aTransactionHandlersArray )

    {

    CPEngOutGoingTransContainer* self = NewLC( aRequestHandler,

                                               aPureDataHandler,

                                               aTransactionHandlersArray );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPEngOutGoingTransContainer::NewL

// Two-phased constructor.

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

//

CPEngOutGoingTransContainer* CPEngOutGoingTransContainer::NewLC(

    MPEngHandlerSendData& aRequestHandler,

    MPEngPureDataHandler& aPureDataHandler,

    RPointerArray<MPEngOutgoingTransactionHandler>&

    aTransactionHandlersArray )

    {

    CPEngOutGoingTransContainer* self =

        new( ELeave ) CPEngOutGoingTransContainer(

        aRequestHandler,

        aPureDataHandler,

        aTransactionHandlersArray );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CPEngOutGoingTransContainer::~CPEngOutGoingTransContainer()

    {

    PENG_DP( D_PENG_LIT( "CPEngOutGoingTransContainer::~CPEngOutGoingTransContainer()" ) );

    Cancel();

    delete iTransactionHandler;

    }

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

// -------- Function from the CActive ------------------------------------------

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

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

// CPEngOutGoingTransContainer::StartTransaction

// Start performing transaction

// (other items were commented in a header).

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

//

void CPEngOutGoingTransContainer::StartTransactionL(

    MPEngOutgoingTransactionHandler* aOutgoingTransaction )

    {

    PENG_DP( D_PENG_LIT( "CPEngOutGoingTransContainer::StartTransactionL()" ) );

    TPtr8 outgoingBuffer( iPureDataHandler.TransferBufferL() );

    aOutgoingTransaction->RequestL( outgoingBuffer );

    iTransactionId = iPureDataHandler.SendDataL( iStatus );

    SetActive();

    // take ownership of transaction

    iTransactionHandler = aOutgoingTransaction;

    }

// =============================================================================

// ============== Function from the CActive ====================================

// =============================================================================

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

// CPEngOutGoingTransContainer::RunL

// Handles an active object’s request completion event.

// (other items were commented in a header).

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

//

void CPEngOutGoingTransContainer::RunL()

    {

    // what is necessary depends how request went

    TInt errCode ( iStatus.Int() );

    PENG_DP( D_PENG_LIT( "CPEngOutGoingTransContainer::RunL() - result:  %d" ),

             errCode );

    switch ( errCode )

        {

        case KErrNone:

            {

            HBufC8* response = iPureDataHandler.ResponseL( iTransactionId );

            User::LeaveIfNull( response );

            CleanupStack::PushL( response );

            TBool last ( iRequestHandler.LastRunningTransaction() );

            if ( last )

                {

                iTransactionHandler->LastRunningTransactionHandler();

                }

            // TO-DO do processing asynchronous

            iTransactionHandler->ProcessResponseL( *response, iStatus );

            CleanupStack::PopAndDestroy( response ); // response

            iTransactionHandler->NewTransactionHandlersL(

                iNewTransactionHandlers );

            if ( iNewTransactionHandlers.Count() != 0 )

                {

                // new transaction handlers were created, inform RequestHandler

                iRequestHandler.CreateNewContainersRunThemL();

                }

            if ( !iTransactionHandler->TransactionCompleted() )

                {

                // we are not done, just run another round

                StartTransactionL( iTransactionHandler );

                return;

                }

            break;

            }

        default:

            {

            // transfer error code

            iTransactionHandler->ReleaseHandler();

            }

        }

    // Get status and complete container, status ownership transfered

    CPEngTransactionStatus* status =

        iTransactionHandler->TransactionResult();

    iRequestHandler.CompleteTransContainer( this, status, errCode );

    PENG_DP( D_PENG_LIT( "CPEngOutGoingTransContainer::RunL() - End" ) );

    }

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

// CPEngOutGoingTransContainer::RunError

// Handles a leave occurring in the request completion event handler RunL()

// implementation should return KErrNone, if it handles the leave

// (other items were commented in a header).

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

//

TInt CPEngOutGoingTransContainer::RunError(

    TInt aError )

    {

    // release handler and complete container

    iTransactionHandler->ReleaseHandler();

    // Get status and complete container, status ownership transfered

    CPEngTransactionStatus* status =

        iTransactionHandler->TransactionResult();

    iRequestHandler.CompleteTransContainer( this, status, aError );

    return KErrNone;

    }

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

// CPEngOutGoingTransContainer::DoCancel

// Implements cancellation of an outstanding request.

// (other items were commented in a header).

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

//

void CPEngOutGoingTransContainer::DoCancel()

    {

    PENG_DP( D_PENG_LIT( "CPEngOutGoingTransContainer::DoCancel()" ) );

    // request was canceled, cancel log in, update state and complete RMessage

    iPureDataHandler.CancelSending( iTransactionId );

    iTransactionHandler->ReleaseHandler();

    // Container is not removed here

    }

//  End of File