/*

* Copyright (c) 2004 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:  Access handler of the network session

*

*/

// INCLUDE FILES

#include "CPEngPureDataHandler.h"

#include "PEngTransAdapterPanics.h"

#include "CPEngSendDataOperation.h"

#include "MPEngSessionManager.h"

#include "MPEngAccessHandler.h"

// Packet logger

#include "PEngPacketLogger.h"

// CONSTANTS

const TInt KOpIdInitvalue = 1000;

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

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

// CPEngPureDataHandler::CPEngPureDataHandler

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

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

//

CPEngPureDataHandler::CPEngPureDataHandler(

    MPEngSessionManager& aSessManager,

    MPEngAccessHandler& aAccessHandler,

    const CPEngSessionSlotId& aSessionId,

    RImpsEng& aSessClient )

        : iCount( 1 ), // init to 1

        iSessionManager( aSessManager ),

        iAccessHandler( aAccessHandler ),

        iSessionId( aSessionId ),

        iSessClient( aSessClient ),

        iOpidIterator( KOpIdInitvalue )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::CPEngPureDataHandler" ) );

    iAccessHandler.Open(); // CSI: 65 #

    iSessionManager.OpenRef();

    }

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

// CPEngPureDataHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngPureDataHandler::ConstructL(

    RImpsEng& aSessClient )

    {

    iPureClient.RegisterL(  aSessClient,            // main client

                            this,                   // Observer

                            EImpsServicePresence,   // Type of service

                            ETrue,                  // Incoming data interest

                            ETrue );                // Any content type

    iPureClient.RegisterErrorObserverL( *this );

    TInt bufferSize ( iPureClient.MaxTransactionContentLengthL() );

    // if size is zero, leave cause WV Engine is not ready

    if ( bufferSize == 0 )

        {

        User::Leave( KErrNotReady );

        }

    iTrasferBuffer = HBufC8::NewL( bufferSize );

#ifdef PENG_ENABLE_DEBUG_PRINT

    // init logs connection Id

    iConnectionLogsId = PEngPacketLogger::GetConnectionId();

#endif

    }

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

// CPEngPureDataHandler::NewLC()

// Two-phased constructor.

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

//

CPEngPureDataHandler* CPEngPureDataHandler::NewL(

    RImpsEng& aSessClient,

    MPEngSessionManager& aSessManager,

    MPEngAccessHandler& aAccessHandler,

    const CPEngSessionSlotId& aSessionId )

    {

    CPEngPureDataHandler* self = new ( ELeave ) CPEngPureDataHandler(

        aSessManager,

        aAccessHandler,

        aSessionId,

        aSessClient );

    CleanupClosePushL( *self );

    self->ConstructL( aSessClient );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CPEngPureDataHandler::~CPEngPureDataHandler()

    {

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

    delete iTrasferBuffer;

    iIncomingData.ResetAndDestroy();

    if ( iIncReqStatus )

        {

        User::RequestComplete( iIncReqStatus, KErrCancel );

        }

    iPureClient.Unregister();

    iSessionManager.ClosePureDataHandler();

    // destroy arrays, operations are canceled

    iOperations.ResetAndDestroy();

    iAccessHandler.UnregisterSessionObserver( *this );

    iAccessHandler.Close();

    }

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

// =============== New Functions of the MPEngPureDataHandler ===================

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

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

// CPEngPureDataHandler::Close()

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

//

void CPEngPureDataHandler::Close()

    {

    iCount--;

    if ( iCount == 0 )

        {

        delete this;

        }

    }

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

// CPEngPureDataHandler::TransferBufferL()

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

//

TPtr8 CPEngPureDataHandler::TransferBufferL()

    {

    TPtr8 buf = iTrasferBuffer->Des();

    buf.Zero();

    return buf;

    }

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

// CPEngPureDataHandler::SendDataL()

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

//

TInt CPEngPureDataHandler::SendDataL(

    TRequestStatus& aStatus )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::SendDataL:" ) );

    if ( iTrasferBuffer->Length() == 0 )

        {

        // buffer is empty, nothing to send, leave

        User::Leave( KErrArgument );

        }

    // allocate slot in array by adding NULL pointer and removing it

    iOperations.AppendL( NULL );

    iOperations.Remove( iOperations.Count() - 1 );

    CPEngSendDataOperation* operation =

        CPEngSendDataOperation::NewLC();

    TInt opId( iPureClient.SendPureDataL( *iTrasferBuffer ) );

    operation->SetIds( opId, iOpidIterator++ );

#ifdef PENG_ENABLE_DEBUG_PRINT

    iConnectionLogsId = PEngPacketLogger::WriteOutPacket(

                            *iTrasferBuffer,

                            operation->LogId(),

                            opId,

                            iConnectionLogsId,

                            iSessionId.UserId(),

                            iSessionId.ServiceAddress() );

#endif

    iOperations.Append( operation );

    CleanupStack::Pop(); // operation

    // now it is safe to set request status

    operation->SetRequestStatus( aStatus );

    aStatus = KRequestPending;

    return opId;

    }

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

// CPEngPureDataHandler::ResponseLC()

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

//

HBufC8* CPEngPureDataHandler::ResponseL(

    TInt aTransId )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::ResponseL - id:  %d" ), aTransId );

    // is it incoming data request

    if ( aTransId == 0 )

        {

        if ( iIncomingData.Count() == 0 )

            {

            User::Leave( KErrNotFound );

            }

        // take first one from the array

        HBufC8* buff = iIncomingData[ 0 ];

        iIncomingData.Remove( 0 );

        return buff;

        }

    // try to find operation

    TInt x( FindOperationL( aTransId, CPEngSendDataOperation::OperationId ) );

    // is operation completed?

    TRequestStatus* status = iOperations[ x ]->Status();

    if ( status && ( *status == KRequestPending ) )

        {

        User::Leave( KErrNotReady );

        }

    // send buffer and remove operation

    HBufC8* buff = iOperations[ x ]->Response();

    delete iOperations[ x ];

    iOperations.Remove( x );

    return buff;

    }

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

// CPEngPureDataHandler::CancelSending()

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

//

void CPEngPureDataHandler::CancelSending(

    TInt aTransId )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::CancelSending - id:  %d" ),

             aTransId );

    // try to find operation

    TInt x( FindOperation( aTransId, CPEngSendDataOperation::OperationId ) );

    if ( x == KErrNotFound )

        {

        // nothing to cancel

        return;

        }

    TRequestStatus* status = iOperations[ x ]->Status();

    if ( status && ( *status == KRequestPending )  )

        {

        // operation pending, cancel it

        iPureClient.CancelTransaction(  aTransId );

        iOperations[ x ]->CompletedOperation( KErrCancel );

        }

    delete iOperations[ x ];

    iOperations.Remove( x );

    }

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

// CPEngPureDataHandler::ListenIncomingData()

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

//

TInt CPEngPureDataHandler::ListenIncomingData(

    TRequestStatus& aStatus )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::ListenIncomingData" ) );

    __ASSERT_DEBUG( !iIncReqStatus,

                    User::Panic( KPEngTransferAdapterPanic,

                                 EListenerAlreadyActive )

                  );

    iIncReqStatus = &aStatus;

    aStatus = KRequestPending;

    return iIncomingData.Count();

    }

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

// CPEngPureDataHandler::CancelListening()

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

//

void CPEngPureDataHandler::CancelListening()

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::CancelListening" ) );

    if ( iIncReqStatus )

        {

        User::RequestComplete( iIncReqStatus, KErrCancel );

        iIncReqStatus = NULL;

        }

    }

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

// =============== New Functions of the MImpsPureHandler =======================

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

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

// CPEngPureDataHandler::HandlePureDataL()

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

//

void CPEngPureDataHandler::HandlePureDataL(

    TInt aOpId,

    const TDesC8& aBuffer,

    TImpsCspIdentifier& /* aCspId*/ )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::HandlePureDataL - id:  %d" ),

             aOpId );

    // is it incoming data handler

    if ( aOpId == 0 )

        {

#ifdef PENG_ENABLE_DEBUG_PRINT

        iConnectionLogsId = PEngPacketLogger::WriteNotifyPacket(

                                aBuffer,

                                iLastServerOpId,

                                iConnectionLogsId,

                                iSessionId.UserId(),

                                iSessionId.ServiceAddress() );

#endif

        HBufC8* buff = aBuffer.AllocLC();

        iIncomingData.AppendL( buff );

        CleanupStack::Pop(); // buff

        if ( iIncReqStatus )

            {

            User::RequestComplete( iIncReqStatus, KErrNone );

            iIncReqStatus = NULL;

            }

        return;

        }

    // get buffer and store it in the correct Operation if it is our operation

    TInt x( FindOperationL( aOpId, CPEngSendDataOperation::OperationId ) );

    if ( x != KErrNotFound )

        {

#ifdef PENG_ENABLE_DEBUG_PRINT

        iConnectionLogsId = PEngPacketLogger::WriteInPacket(

                                aBuffer,

                                iOperations[ x ]->LogId(),

                                aOpId,

                                iConnectionLogsId,

                                iSessionId.UserId(),

                                iSessionId.ServiceAddress() );

        iLastServerOpId = iOperations[ x ]->LogId();

#endif

        iOperations[ x ]->SetResponse( aBuffer.AllocL() );

        iOperations[ x ]->CompletedOperation( KErrNone );

        }

    }

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

// =============== New Functions of the MImpsErrorHandler ======================

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

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

// CPEngPureDataHandler::HandleErrorL()

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

//

void CPEngPureDataHandler::HandleErrorL(

    TInt aStatus,

    TInt aOpId,

    const TDesC* /*aDescription*/,

    const CImpsDetailed* /* aDetailedRes*/,

    TImpsCspIdentifier& /*aCspId*/ )

    {

    PENG_DP( D_PENG_LIT( "CPEngPureDataHandler::HandleErrorL - id:  %d, %d" ),

             aStatus,

             aOpId );

    // get buffer and store it in the correct Operation

    TInt x( FindOperationL( aOpId, CPEngSendDataOperation::OperationId ) );

#ifdef PENG_ENABLE_DEBUG_PRINT

    iConnectionLogsId = PEngPacketLogger::WriteError(

                            aStatus,

                            iOperations[ x ]->LogId(),

                            aOpId,

                            iConnectionLogsId,

                            iSessionId.UserId(),

                            iSessionId.ServiceAddress() );

#endif

    iOperations[ x ]->CompletedOperation( aStatus );

    }

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

// ============== New Functions of the MPEngSessionStatusObserver ==============

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

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

// CPEngPureDataHandler::HandleErrorL()

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

//

void CPEngPureDataHandler::StatusChangedL(

    TPEngNWSessionSlotState aNewState,

    TPEngNWSessionSlotEvent /*aNewEvent*/ )

    {

    if ( aNewState == EPEngNWPresenceSessionClosed )

        {

        // cancel all operations

        iOperations.ResetAndDestroy();

        }

    }

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

// =============== New Functions of main class =================================

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

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

// CPEngPureDataHandler::Open()

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

//

void CPEngPureDataHandler::Open()

    {

    iCount++;

    }

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

// =============== New private Functions of the base class =====================

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

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

// CPEngPureDataHandler::FindOperation()

// Find operation in array

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

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

//

TInt CPEngPureDataHandler::FindOperation(

    TInt aOpId,

    TInt ( CPEngSendDataOperation:: *aIdFunc )() const ) const

    {

    TInt count ( iOperations.Count() );

    for ( TInt x( 0 ) ; x < count ; ++x )

        {

        if ( aOpId == ( ( *iOperations[ x ] ).*aIdFunc )() )

            {

            return x;

            }

        }

    return KErrNotFound;

    }

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

// CPEngPureDataHandler::FindOperationL()

// Find operation in array, leave if not found

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

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

//

TInt CPEngPureDataHandler::FindOperationL(

    TInt aOpId,

    TInt ( CPEngSendDataOperation:: *aIdFunc )() const ) const

    {

    TInt x ( FindOperation( aOpId, aIdFunc ) );

    if ( x == KErrNotFound )

        {

        User::Leave( KErrNotFound );

        }

    return x;

    }

// End of File