/** @file

* Copyright (c) 2005-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:  CUpnpTcpSessionReader is a class responsible for 

*                   asynchronous reading from socket owned by CUpnpTcpSession.

*

*/

#include "upnptcpsession.h"

#include "upnptcpsessionreader.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include "inet6err.h"

static const TInt KMaxRetryErrors = 5;

static const TInt KRetryWaitTime = 1000000;

static const TInt KTwoSec = 2000000;

static const TInt KOneSec = 1000000;

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

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

// CUpnpTcpSessionReader::NewL

// Factory method.

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

//

CUpnpTcpSessionReader* CUpnpTcpSessionReader::NewL( CUpnpTcpSession& aSession,

                                                    RSocket& aSocket,

                                                    TThreadPriority aPriority,

                                                    TInt aBufferSize )

    {

    CUpnpTcpSessionReader* self = new ( ELeave ) 

                CUpnpTcpSessionReader( aSession, aSocket, aPriority, aBufferSize );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpTcpSessionReader::CUpnpTcpSessionReader

// C++ constructor.

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

//

CUpnpTcpSessionReader::CUpnpTcpSessionReader( CUpnpTcpSession& aSession,

                                              RSocket& aSocket, 

                                              TThreadPriority aPriority,

                                              TInt aBufferSize )

    :CActive( aPriority ),

    iSocket( aSocket ),

    iSession( aSession ),

    iBufferSize( aBufferSize )

    {

    LOGS1( "%i, CUpnpTcpSessionReader::CUpnpTcpSessionReader", iSession.Id() );

    }

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

// CUpnpTcpSessionReader::TcpConstructL

// Two-phased constructor

// constructor that can leave. Used from derived classes.

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

//

void CUpnpTcpSessionReader::ConstructL()

    {

    CActiveScheduler::Add( this );

    iReceiveBuffer.CreateL( iBufferSize );

    iRetryTimer = CUpnpNotifyTimer::NewL( this );

    iCancelTimer = CUpnpNotifyTimer::NewL( this );        

    }

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

// CUpnpTcpSessionReader::~CUpnpTcpSessionReader

// Destructor.

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

//

CUpnpTcpSessionReader::~CUpnpTcpSessionReader()

    {

    LOGS1( "%i, CUpnpTcpSessionReader::~CUpnpTcpSessionReader", iSession.Id() );

    Cancel();

    iReceiveBuffer.Close();  

    delete iRetryTimer;

    delete iCancelTimer;   

    }

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

// CUpnpTcpSessionReader::Start

// Starts reading.

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

//

void CUpnpTcpSessionReader::Start()

    {

    LOGS1( "%i, CUpnpTcpSessionReader::Start", iSession.Id() );

    // Initiate a new read from socket into iBuffer

    if ( !IsActive() )

        {

        IssueRead();

        }

    }    

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

// CUpnpTcpSessionReader::DoCancel

// From class CActive.

// Cancels issued reading.

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

//

void CUpnpTcpSessionReader::DoCancel()

    {

    LOGS1( "%i, CUpnpTcpSessionReader::DoCancel", iSession.Id() );

    // Cancel asychronous read request

    iSocket.CancelRead();

    }

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

// CUpnpTcpSessionReader::CancelRetry

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

//

void CUpnpTcpSessionReader::CancelTimers()

    {

	iRetryTimer->Cancel();

	iCancelTimer->Cancel();

    }       

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

// CUpnpTcpSessionReader::RunL

// From class CActive.

// Function is called as a callback when the issued reading is completed.

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

//

void CUpnpTcpSessionReader::RunL()

    {

    LOGS2( "%i, CUpnpTcpSessionReader::RunL(), iStatus %i",

    		iSession.Id(), iStatus.Int() );

    // Active object request complete handler

    switch ( iStatus.Int() )

        {

        case KErrNone:

           	iRetryErrorCount = 0;

           	iCancelTimer->Cancel();

            // Forward read data to HTTPSession 

            iSession.ReceivingCompletedL( iReceiveBuffer );

            break;

         case KErrCancel:

            if(iCancelFromTimer) 

                {          

                IssueRead();

                iCancelFromTimer = EFalse;

                }

            break;

        case KErrNoMemory:

        case KErrNotReady:

        case KErrInet6AddressExpired:

            if( iRetryErrorCount < KMaxRetryErrors )

	            {

	        	iRetryTimer->Cancel();

				iRetryTimer->After( KRetryWaitTime * ++iRetryErrorCount, EFalse );

				break;

	            }

        default:

            iSession.HandleErrorL( iStatus.Int() );

            break;

        }

    }

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

// CUpnpTcpSessionWriter::RunError

// RunError is called when RunL leaves.

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

//

TInt CUpnpTcpSessionReader::RunError( TInt aError )

    {

    LOGS2( "%i, CUpnpTcpSessionReader::RunError - %d"

    		, iSession.Id(), aError);

    return KErrNone;

    }

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

// CUpnpTcpSessionReader::TimerEventL

// Retry read

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

//        

void CUpnpTcpSessionReader::TimerEventL( CUpnpNotifyTimer* aTimer )

    {

    if( aTimer == iCancelTimer )

        {

        iCancelFromTimer = ETrue;

        iSocket.CancelRecv();

        }

    else if( aTimer == iRetryTimer )

        {

        IssueRead();

        }

    }

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

// CUpnpTcpSessionReader::StartCancelTimer

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

//  

void CUpnpTcpSessionReader::StartCancelTimer()

    {

    TInt timeout = iSession.TimeoutCurrentValue();

   	iCancelTimer->Cancel();

   	timeout = timeout/2 - KTwoSec;

   	if( timeout <= 0 ) timeout = KOneSec;

	iCancelTimer->After( timeout, EFalse );

    iCancelFromTimer = EFalse;

    }

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

// CUpnpTcpSessionReader::IssueRead

// Issues reading.

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

//

void CUpnpTcpSessionReader::IssueRead()

    {

    LOGS1( "%i, CUpnpTcpSessionReader::IssueRead", iSession.Id());

    // Initiate a new read from socket into iBuffer

    if( IsActive() )

        {

        LOGS1( "%i, PANIC: CUpnpTcpSessionReader::IssueRead!", iSession.Id() );

        User::Panic( _L("CUpnpTcpSessionReader is active" ), KErrGeneral );    

        } 

    if( iSession.IsConnected() )

        {

      	LOGS1( "%i, CUpnpTcpSessionReader::IssueRead"

          	, iSession.Id());

        Deque();

        CActiveScheduler::Add(this);

        iReceiveBuffer.Zero();

        StartCancelTimer();

        iSocket.RecvOneOrMore( iReceiveBuffer, 0, iStatus, iLen );   

        SetActive();

        }

    }

//  End of File