/*
* Copyright (c) 2002-2003 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:   
*
*/




#include "rtpcommsend.h"

// CONSTANTS

/////////////////////Class CRtpCommSend///////////////////////////////////////
// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------------------------
// Set to address
// ---------------------------------------------------------------------------
// 
void CRtpCommSend::SetToAddress(TInetAddr& aAddr)
    {
    iToAddr.SetAddress( aAddr.Address() ); 
    iToAddr.SetPort( aAddr.Port() );     
    if (aAddr.Family() == KAfInet6 )
    	{
    	iToAddr.SetAddress( aAddr.Ip6Address() ); 
    	}  
    }

// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CRtpCommSend::CRtpCommSend( RSocket& aSocket, MRtpErrNotify& aErrNotify, TInetAddr& aAddr ) 
    : CActive( EPriorityStandard ), 
      iSocket( aSocket ),
      iToAddr(aAddr),      
      iWriteStatus( EWaiting ),
      iBufPtr( NULL, 0 ),
      iRtpErrNotify( aErrNotify ),
      iSendQue(CRtpSendItem::iOffset ),
      iQueueIter(iSendQue)
    {
    CActiveScheduler::Add( this );
    }
  
// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
// 
void CRtpCommSend::ConstructL( /*TInt aBufSize */)
    {

   	}

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CRtpCommSend* CRtpCommSend::NewL( RSocket& aSocket, MRtpErrNotify& aErrNotify,
                                  /*TInt aBufSize,*/ TInetAddr& aAddr )
    {
    CRtpCommSend* self = new ( ELeave ) CRtpCommSend( aSocket, aErrNotify, aAddr );
    CleanupStack::PushL( self );
    self->ConstructL( /*aBufSize*/ );
    CleanupStack::Pop(); //self
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// 
// ---------------------------------------------------------------------------
//
CRtpCommSend::~CRtpCommSend()
    {
    Cancel();
    CompleteAndRemoveRequests( KErrAbort );
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::RunL()
// Called when request has completed.
// ---------------------------------------------------------------------------
//
void CRtpCommSend::RunL()
    {
    // Active object request complete handler
    if ( iStatus == KErrNone )
        {
        RemoveFromQueue();
		
        switch( iWriteStatus )
            {
            case ESending:
                SendNextPacket();
                break;
            default:
                RTP_DEBUG_DETAIL( "Tx state error" );
                User::Leave( KErrInUse );
                break;
            }
        }
    else 
        {
        RTP_DEBUG_DETAIL_DVALUE( "CRtpCommSend::RunL, ERR: ", iStatus.Int() );
        
        // Client originated cancelling is handled in CancelAsyncSend() function.
        if ( KErrCancel != iStatus.Int() )
            {
            CompleteAndRemoveRequests( iStatus.Int() );
            }
        
        iRtpErrNotify.ErrorNotify( iStatus.Int() );
        }
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::RemoveFromQueue()
// Remove Item from Queue
// ---------------------------------------------------------------------------
//
void CRtpCommSend::RemoveFromQueue()
	{
	if ( !( iSendQue.IsEmpty() ) )
		{
		CRtpSendItem* item = iSendQue.First();
		CompleteClientRequest( *item, KErrNone );
		iSendQue.Remove(*item);
		delete item;
		}
	}
// ---------------------------------------------------------------------------
// CRtpCommSend::DoCancel()
// Cancel ongoing requests.
// ---------------------------------------------------------------------------
//
void CRtpCommSend::DoCancel()
    {	
    // Cancel asychronous send request
    CancelAsyncSend();
    } 

// ---------------------------------------------------------------------------
// CRtpCommSend::CancelAsyncSend()
// 
// ---------------------------------------------------------------------------
//
void CRtpCommSend::CancelAsyncSend()
	{
    RTP_DEBUG_DETAIL( "CRtpCommSend::CancelAsyncSend" );

    iSocket.CancelSend();
    CompleteAndRemoveRequests( KErrCancel );
	}

// ---------------------------------------------------------------------------
// CRtpCommSend::Send()
// 
// ---------------------------------------------------------------------------
//
void CRtpCommSend::Send( const TDesC8& aPacket, TRequestStatus& aStatus )
    {
    RTP_DEBUG_DETAIL( "CRtpCommSend::Send -- ASynchronous" );
    
    aStatus = KRequestPending;
    
    TInt err( KErrNone );
    TRAP( err, 
        iSendQue.AddLast( *CRtpSendItem::NewL( aPacket, iStatus, aStatus ) ) );
    
    if ( KErrNone == err )
        {
        if ( !IsActive() )
            {
            SendNextPacket();
            }
        }
    else
        {
        // Probably out of memory, so don't send any more packets
        TRequestStatus* status = &aStatus;
        User::RequestComplete( status, err );
        CompleteAndRemoveRequests( err );
        RTP_DEBUG_DETAIL( "Error Occured while put Packet to Send Item Que" );
        iRtpErrNotify.ErrorNotify( err );
        }
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::Send()
// 
// ---------------------------------------------------------------------------
//
TInt CRtpCommSend::Send( const TDesC8& aPacket )
    {
    RTP_DEBUG_DETAIL( "CRtpCommSend::Send -- Synchronous Entry" );
    
    TInt err( KErrNone );
    if ( ( iWriteStatus != EWaiting ) && ( iWriteStatus != ESending ) )
        {
        RTP_DEBUG_DETAIL( "Write status is not correct" );
        return KErrDisconnected;
        }
    
    // Put in in our buffer
    TRAP( err, iSendQue.AddLast(*CRtpSendItem::NewL(aPacket, iStatus)) );
	RTP_DEBUG_DETAIL( "Put Packet to Send Item Que" );
    
    if ( err != KErrNone )
        {
        // Probably out of memory, so don't send any more packets
        CompleteAndRemoveRequests( err );
        
		RTP_DEBUG_DETAIL( "Error Occured while put Packet to Send Item Que" );
        return err;
        }
    
    if ( !IsActive() )
        {
        SendNextPacket();
		}
	
	RTP_DEBUG_DETAIL( "CRtpCommSend::Send -- Synchronous Exit" );
    return err;
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::SendNextPacket()
// Write data from buffer to socket.
// ---------------------------------------------------------------------------
//
void CRtpCommSend::SendNextPacket()
    {
    RTP_DEBUG_DETAIL( "CRtpCommSend::SendNextPacket Entry" );
    
    iWriteStatus = EWaiting;
    iQueueIter.SetToFirst();
	CRtpSendItem* item;
    if ( ( item=iQueueIter++ ) != NULL )
        {
        iSocket.SendTo( item->GetData(), iToAddr, 0, item->iStatus );
        SetActive();
        iWriteStatus = ESending;
        }

    RTP_DEBUG_DETAIL( "CRtpCommSend::SendNextPacket Exit" );
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::CompleteAndRemoveRequests()
// Removes all requests in the queue.
// ---------------------------------------------------------------------------
//
void CRtpCommSend::CompleteAndRemoveRequests( TInt aError )
    {
    RTP_DEBUG_DETAIL( "CRtpCommSend::CompleteAndRemoveRequests Entry" );
    
    CRtpSendItem* item;
    iQueueIter.SetToFirst();
    item = iQueueIter++;
    while ( item )
        {
        CompleteClientRequest( *item, aError );
        iSendQue.Remove( *item );
        delete item;
        item = iQueueIter++;
        }
    
    RTP_DEBUG_DETAIL( "CRtpCommSend::CompleteAndRemoveRequests Exit" );
    }

// ---------------------------------------------------------------------------
// CRtpCommSend::CompleteClientRequest()
// Completes the request.
// ---------------------------------------------------------------------------
//
void CRtpCommSend::CompleteClientRequest( CRtpSendItem& aItem, 
    TInt aReason ) const
    {
    RTP_DEBUG_DETAIL( "CRtpCommSend::CompleteClientRequest Entry" );

    TRequestStatus* status = aItem.ClientStatus();
    if ( NULL != status )
        {
        User::RequestComplete( status, aReason );
        }
    }

// End of file