/*

* 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:  Request Handler to update data to the network server

*

*/

// INCLUDE FILES

#include    "CPEngHandlerSendData.h"

#include    <e32std.h>

#include	"MPEngRequestHandlerObserver.h"

#include	"CPEngOutGoingTransContainer.h"

#include	"MPEngOutgoingTransactionHandler.h"

#include	"MPEngSubSession.h"

#include	"PEngWVPresenceErrors2.h"

#include	"CPEngTransactionStatus.h"

//	Debug prints

#include	"PresenceDebugPrint.h"

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

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

// CPEngHandlerSendData::CPEngHandlerSendData

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

// might leave.

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

//

CPEngHandlerSendData::CPEngHandlerSendData(

    MPEngRequestHandlerObserver& aRequestHandlerObserver,

    MPEngPureDataHandler& aPureDataHandler,

    MPEngSubSession& aServSubSession,

    const RPEngMessage& aMessage,

    TInt32 aSessionId,

    TInt32 aSubSessionId )

        : iRequestHandlerObserver( aRequestHandlerObserver ),

        iPureDataHandler( aPureDataHandler ),

        iServSubSession( aServSubSession ),

        iSessionId( aSessionId ),

        iSubSessionId( aSubSessionId ),

        iFunction( aMessage.Function() )

    {

    }

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

// CPEngHandlerSendData::ConstructHandlerFromTransactionHandlersL

// Symbian 2nd phase constructor can leave.

// Construct Send Data handler from the passed array of the outgoing Transaction handlers

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

//

void CPEngHandlerSendData::ConstructL(

    RPointerArray<MPEngOutgoingTransactionHandler>& aTransactions )

    {

    // copy handlers from the given array, but just their pointers, it takes ownership

    for ( TInt x( aTransactions.Count() - 1 ) ; x >= 0 ; x-- )

        {

        User::LeaveIfError( iOutgoingTransactionHandlers.Append( aTransactions[ x ] ) );

        aTransactions.Remove( x );

        }

    iTransactionStatus = CPEngTransactionStatus::NewL();

    }

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

// CPEngHandlerSendData::NewHandlerFromTransactionHandlersLC

// Two-phased constructor. which creates Send Data handler from the passed array of the

// Transaction handlers, no reading of the storage IDs from the client side is needed then

// are readed from the client RPEngMessage

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

//

CPEngHandlerSendData* CPEngHandlerSendData::NewLC(

    MPEngRequestHandlerObserver&  aRequestHandlerObserver,

    MPEngPureDataHandler& aPureDataHandler,

    MPEngSubSession& aServSubSession,

    const RPEngMessage& aMessage,

    RPointerArray<MPEngOutgoingTransactionHandler>& aTransactions,

    TInt32 aSessionId,

    TInt32 aSubSessionId )

    {

    CPEngHandlerSendData* self = new( ELeave ) CPEngHandlerSendData(

        aRequestHandlerObserver,

        aPureDataHandler,

        aServSubSession,

        aMessage,

        aSessionId,

        aSubSessionId );

    CleanupStack::PushL( self );

    self->ConstructL( aTransactions );

    return self;

    }

// Destructor

CPEngHandlerSendData::~CPEngHandlerSendData()

    {

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

    // cancel and delete all transaction containers

    iTrasactionContainersArray.ResetAndDestroy();

    iOutgoingTransactionHandlers.ResetAndDestroy();

    delete iTransactionStatus;

    // complete message with KErrCancel, just in case it was not completed yet

    iMessage.Complete( KErrCancel );

    // remove handler from the CSP Session manager

    iRequestHandlerObserver.CompleteRequestHandler( this );

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::~CPEngHandlerSendData - End" ) );

    }

/////////////////////////////////////////////////////////////////////////////////

// =============== New Functions of the MPEngRequestHandler class ==============

/////////////////////////////////////////////////////////////////////////////////

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

// CPEngHandlerSendData::StartHandlerL

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

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

//

void CPEngHandlerSendData::StartHandlerL( )

    {

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::StartHandlerL" ) );

    // create containers and run them

    CreateNewContainersRunThemL();

    }

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

// CPEngHandlerSendData::SessionId

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

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

//

TInt32 CPEngHandlerSendData::SessionId( ) const

    {

    return iSessionId;

    }

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

// CPEngHandlerSendData::SubSessionId

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

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

//

TInt CPEngHandlerSendData::SubSessionId( ) const

    {

    return iSubSessionId;

    }

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

// CPEngHandlerSendData::RequestFunction

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

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

//

TInt CPEngHandlerSendData::RequestFunction( ) const

    {

    return iFunction;

    }

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

// CPEngHandlerSendData::CancelRequest

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

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

//

void CPEngHandlerSendData::CancelRequestD( )

    {

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::CancelRequest" ) );

    // delete containers and complete message

    iTrasactionContainersArray.ResetAndDestroy();

    iMessage.Complete( KErrCancel );

    // now we are done and handler can be deleted

    delete this;

    }

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

// CPEngHandlerSendData::SetMessage

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

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

//

void CPEngHandlerSendData::SetMessage(

    const RPEngMessage& aMessage )

    {

    iMessage = aMessage;

    }

/////////////////////////////////////////////////////////////////////////////////

// =============== New Functions of the MPEngHandlerSendData class =============

/////////////////////////////////////////////////////////////////////////////////

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

// CPEngHandlerSendData::CompleteRequestD

// Complete request handlers, store request result and delete itself

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

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

//

void CPEngHandlerSendData::CompleteRequestD()

    {

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::CompleteRequestL" ) );

    // get transaction result and store it in SubSession

    HBufC8* volatile reqResult = NULL;

    TRAPD( e, reqResult = iTransactionStatus->PackResultsL() );

    // if error complete with error

    if ( e != KErrNone )

        {

        iMessage.Complete( e );

        delete this;

        return;

        }

    iServSubSession.StoreRequestResponse( reqResult );

    // complete RPEngMessage and delete itself

    iMessage.Complete( reqResult->Length() );

    delete this;

    }

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

// CPEngHandlerSendData::CreateContainersAndRunThemL

// go through all transaction handlers in iOutgoingTransactionHandlers

// array, create for each of then container with given Transaction handler

// and start it

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

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

//

void CPEngHandlerSendData::CreateNewContainersRunThemL()

    {

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::CreateNewContainersRunThemL" ) );

    // we have to go through array from the end, created

    // transaction containers are taking owner ship of the transaction

    // handler from the array, so they have to be removed from there

    for ( TInt i( iOutgoingTransactionHandlers.Count() - 1 ) ; i >= 0 ; i-- )

        {

        CPEngOutGoingTransContainer* newContainer = CPEngOutGoingTransContainer::NewLC(

                                                        *this,

                                                        iPureDataHandler,

                                                        iOutgoingTransactionHandlers );

        newContainer->StartTransactionL( iOutgoingTransactionHandlers[ i ] );

        iOutgoingTransactionHandlers.Remove( i );

        // remove trans. handler from the array since its ownership was

        // taken by transaction container

        iTrasactionContainersArray.AppendL( newContainer );

        CleanupStack::Pop( newContainer ); // newContainer

        }

    }

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

// CPEngHandlerSendData::CompleteTransContainer

// Remove transaction container from the array of containers

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

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

//

void CPEngHandlerSendData::CompleteTransContainer(

    CPEngOutGoingTransContainer* aTransContainer,

    CPEngTransactionStatus* aTransactionStatus,

    TInt aErrCode )

    {

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::CompleteTransContainer" ) );

    // inport transaction status

    iTransactionStatus->ImportStatusFrom( *aTransactionStatus );

    // find transaction and remove it from the list

    TInt index ( iTrasactionContainersArray.Find( aTransContainer ) );

    if ( index != KErrNotFound )

        {

        if ( KErrCancel != aErrCode &&  aErrCode != KPEngNwErrForcedLogout )

            {

            //Skip the deletion if aErrCode is KErrCancel

            delete iTrasactionContainersArray[ index ];

            }

        iTrasactionContainersArray.Remove( index );

        }

    else

        {

        // if container was not found in array, complete it anyway,

        // however, it should not happen

        delete aTransContainer;

        }

    // end if there was some Symbian error

    if ( aErrCode != KErrNone )

        {

        // cancel all active transaction

        iTrasactionContainersArray.ResetAndDestroy();

        iMessage.Complete( aErrCode );

        delete this;

        }

    else if ( iTrasactionContainersArray.Count() == 0 )

        {

        // we can safely call complete, even this function was

        // most likely called from the destructor of the

        // Transaction Container, it was already removed from the array

        CompleteRequestD();

        }

    PENG_DP( D_PENG_LIT( "CPEngHandlerSendData::CompleteTransContainer - End" ) );

    }

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

// CPEngHandlerSendData::LastRunningTransaction

// Check how many running transactions is still there,

// and if calling one is last, return ETrue

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

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

//

TBool CPEngHandlerSendData::LastRunningTransaction( )

    {

    return ( 1 == iTrasactionContainersArray.Count() );

    }

//  End of File