/*

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

#include "CImpsPluginPureDataHandler.h"

#include "ImpsPluginPanics.h"

#include "CImpsPluginSendDataOperation.h"

#include <flogger.h>

#include <F32File.h>

#include  <APPARC.h>

// CONSTANTS

const TInt KOpIdInitvalue = 1000;

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

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

// CImpsPluginPureDataHandler::CImpsPluginPureDataHandler

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

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

//

CImpsPluginPureDataHandler::CImpsPluginPureDataHandler(

    MImpsPluginAccessHandler& aAccessHandler,

    RImpsEng& aSessClient )

        :

        iAccessHandler( aAccessHandler ),

        iSessClient( aSessClient ),

        iOpidIterator( KOpIdInitvalue )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CImpsPluginPureDataHandler Start-End" ) );

    }

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

// CImpsPluginPureDataHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CImpsPluginPureDataHandler::ConstructL(

    RImpsEng& aSessClient )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ConstructL Start" ) );

    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 );

    User::LeaveIfError( iFs.Connect() );

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ConstructL End %d " ), bufferSize );

#ifdef IMPS_ENABLE_DEBUG_PRINT

    // init logs connection Id

    //iConnectionLogsId = PEngPacketLogger::GetConnectionId();

#endif

    }

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

// CImpsPluginPureDataHandler::NewLC()

// Two-phased constructor.

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

//

CImpsPluginPureDataHandler* CImpsPluginPureDataHandler::NewL(

    RImpsEng& aSessClient,

    MImpsPluginAccessHandler& aAccessHandler )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::NewL Start" ) );

    CImpsPluginPureDataHandler* self = new ( ELeave ) CImpsPluginPureDataHandler(

        aAccessHandler,

        aSessClient );

    CleanupStack::PushL( self );

    self->ConstructL( aSessClient );

    CleanupStack::Pop( self );

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::NewL End" ) );

    return self;

    }

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

// CImpsPluginPureDataHandler::NewLC()

// Destructor

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

//

CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler()

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler Start" ) );

    delete iTrasferBuffer;

    iIncomingData.ResetAndDestroy();

    if ( iIncReqStatus )

        {

        User::RequestComplete( iIncReqStatus, KErrCancel );

        iIncReqStatus = NULL;

        }

    iPureClient.Unregister();

    iOperations.ResetAndDestroy();

    iAccessHandler.UnregisterSessionObserver( *this );

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::~CImpsPluginPureDataHandler End" ) );

    }

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

// =============== New Functions of the MImpsPureDataHandler ===================

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

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

// CImpsPluginPureDataHandler::TransferBufferL()

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

//

TPtr8 CImpsPluginPureDataHandler::TransferBufferL()

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::TransferBufferL Start" ) );

    TPtr8 buf = iTrasferBuffer->Des();

    buf.Zero();

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::TransferBufferL End" ) );

    return buf;

    }

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

// CImpsPluginPureDataHandler::SendDataL()

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

//

TInt CImpsPluginPureDataHandler::SendDataL(

    TRequestStatus& aStatus )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL: Start" ) );

    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 );

    CImpsPluginSendDataOperation* operation =

        CImpsPluginSendDataOperation::NewLC();

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

    // code for xmlfile

    IMPS_DP( D_IMPS_LIT( "*****************************************" ) );

    TFileName fileName = _L( "c:\\logs\\presadap12\\send.xml" );

    User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );

    RFile f;

    if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )

        {

        f.Write( 0, *iTrasferBuffer );

        f.Close();

        }

    IMPS_DP( D_IMPS_LIT( "-------------------------------------------" ) );

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

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL opId %d" ), opId );

    iOperations.Append( operation );

    CleanupStack::Pop( operation ); // operation

    // now it is safe to set request status

    operation->SetRequestStatus( aStatus );

    aStatus = KRequestPending;

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::SendDataL: End" ) );

    return opId;

    }

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

// CImpsPluginPureDataHandler::ResponseLC()

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

//

HBufC8* CImpsPluginPureDataHandler::ResponseL(

    TInt aTransId )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ResponseL Start- id:  %d" ), aTransId );

    // is it incoming data request

    if ( aTransId == 0 )

        {

        IMPS_DP( D_IMPS_LIT( "=======================================================" ) );

        if ( iIncomingData.Count() == 0 )

            {

            User::Leave( KErrNotFound );

            }

        // take first one from the array

        HBufC8* buff = iIncomingData[ 0 ];

        iIncomingData.Remove( 0 );

        TFileName fileName = _L( "c:\\logs\\presadap12\\notification.xml" );

        User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );

        RFile f;

        if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )

            {

            f.Write( 0, *buff );

            f.Close();

            }

        return buff;

        }

    // try to find operation

    TInt x( FindOperationL( aTransId, CImpsPluginSendDataOperation::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 );

    // code for xmlfile

    TFileName fileName = _L( "c:\\logs\\presadap12\\receive.xml" );

    User::LeaveIfError( CApaApplication::GenerateFileName( iFs, fileName ) );

    RFile f;

    if ( f.Create( iFs, fileName, EFileWrite ) == KErrNone )

        {

        f.Write( 0, *buff );

        f.Close();

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ResponseL: End" ) );

    return buff;

    }

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

// CImpsPluginPureDataHandler::CancelSending()

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

//

void CImpsPluginPureDataHandler::CancelSending(

    TInt aTransId )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelSending Start - id:  %d" ),

             aTransId );

    // try to find operation

    TInt x( FindOperation( aTransId, CImpsPluginSendDataOperation::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 );

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelSending End " ) );

    }

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

// CImpsPluginPureDataHandler::ListenIncomingData()

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

//

TInt CImpsPluginPureDataHandler::ListenIncomingData(

    TRequestStatus& aStatus )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ListenIncomingData Start" ) );

    __ASSERT_DEBUG( !iIncReqStatus,

                    User::Panic( KImpsPluginPanic,

                                 EListenerAlreadyActive )

                  );

    if ( !iIncReqStatus )

        {

        iIncReqStatus = &aStatus;

        aStatus = KRequestPending;

        }

    else

        {

        User::Leave( KErrNotReady );

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::ListenIncomingData End Count is %d" ), iIncomingData.Count() );

    return iIncomingData.Count();

    }

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

// CImpsPluginPureDataHandler::CancelListening()

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

//

void CImpsPluginPureDataHandler::CancelListening()

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelListening Start" ) );

    if ( iIncReqStatus )

        {

        User::RequestComplete( iIncReqStatus, KErrCancel );

        iIncReqStatus = NULL;

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::CancelListening End" ) );

    }

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

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

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

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

// CImpsPluginPureDataHandler::HandlePureDataL()

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

//

void CImpsPluginPureDataHandler::HandlePureDataL(

    TInt aOpId,

    const TDesC8& aBuffer,

    TImpsCspIdentifier& /* aCspId*/ )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandlePureDataL - id:  %d" ),

             aOpId );

    // is it incoming data handler

    if ( aOpId == 0 )

        {

        IMPS_DP( D_IMPS_LIT( "=======================================================" ) );

        HBufC8* buff = aBuffer.AllocLC();

        iIncomingData.AppendL( buff );

        CleanupStack::Pop( buff ); // 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, CImpsPluginSendDataOperation::OperationId ) );

    if ( x != KErrNotFound )

        {

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

        iOperations[ x ]->CompletedOperation( KErrNone );

        }

    }

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

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

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

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

// CImpsPluginPureDataHandler::HandleErrorL()

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

//

void CImpsPluginPureDataHandler::HandleErrorL(

    TInt aStatus,

    TInt aOpId,

    const TDesC* /*aDescription*/,

    const CImpsDetailed* /* aDetailedRes*/,

    TImpsCspIdentifier& /*aCspId*/ )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandleErrorL - id:  %d, %d" ),

             aStatus,

             aOpId );

    IMPS_DP( D_IMPS_LIT( "+++++++++++++++++++++++++++++++++++++++++++++++++++++++" ) );

    // get buffer and store it in the correct Operation

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

    iOperations[ x ]->CompletedOperation( aStatus );

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::HandleErrorL End" ) );

    }

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

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

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

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

// CImpsPluginPureDataHandler::HandleErrorL()

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

//

void CImpsPluginPureDataHandler::StatusChangedL(

    TPEngNWSessionSlotState aNewState,

    TPEngNWSessionSlotEvent /*aNewEvent*/ )

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::StatusChangedL Start" ) );

    if ( aNewState == EPEngNWPresenceSessionClosed )

        {

        // cancel all operations

        iOperations.ResetAndDestroy();

        //iPluginHost.HandleConnectionTerminated(

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::StatusChangedL End" ) );

    }

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

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

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

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

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

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

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

// CImpsPluginPureDataHandler::FindOperation()

// Find operation in array

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

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

//

TInt CImpsPluginPureDataHandler::FindOperation(

    TInt aOpId,

    TInt ( CImpsPluginSendDataOperation:: *aIdFunc )() const ) const

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Start" ) );

    TInt count ( iOperations.Count() );

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

        {

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

            {

            IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Returns %d" ), x );

            return x;

            }

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation End" ) );

    return KErrNotFound;

    }

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

// CImpsPluginPureDataHandler::FindOperationL()

// Find operation in array, leave if not found

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

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

//

TInt CImpsPluginPureDataHandler::FindOperationL(

    TInt aOpId,

    TInt ( CImpsPluginSendDataOperation:: *aIdFunc )() const ) const

    {

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation Start" ) );

    TInt x ( FindOperation( aOpId, aIdFunc ) );

    if ( x == KErrNotFound )

        {

        User::Leave( KErrNotFound );

        }

    IMPS_DP( D_IMPS_LIT( "CImpsPluginPureDataHandler::FindOperation End Returns %d" ), x );

    return x;

    }

// End of File