// Copyright (c) 2008-2009 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:

// RTPFlow Implementation

// 

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/ss_log.h>

#include "rtpflow.h"

#include "rtppint.h"

#include "rtp_cfmessages.h"

#if defined(ESOCK_LOGGING_ACTIVE)

_LIT8(KRtpFlowSubTag, "RtpFlow");

#endif

CRtpFlow::CRtpFlow(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf)

:CRtpBaseFlow(aFactory, aSubConnId, aProtocolIntf)

{

	LOG_NODE_CREATE(KESockFlowTag, CRtpFlow);

}

CRtpFlow* CRtpFlow::NewL(CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)

	{

	CRtpFlow *pRtpFlow = new (ELeave) CRtpFlow(aFactory, aSubConn, aProtocolIntf);

	CleanupStack::PushL(pRtpFlow);

	pRtpFlow->ConstructL();

	/* Register the flow with Rtp Pint */

	((CRtpProtocolIntf*)aProtocolIntf)->RegisterSubConnProvIDL(pRtpFlow,aSubConn);

	CleanupStack::Pop();

	return pRtpFlow;

	}

void CRtpFlow::ConstructL()

	{

	TSockAddr addr;

	/* Create the RTP Handler */

	iRtpHandler = CCFRtpHandler::NewL(this,EPriorityNormal);

	iRtpSession = CRtpController::NewL(*iRtpHandler,EPriorityNormal,addr, _L8(""));

	iRtpBuffer.ReAllocL(KRtpDefBufSz);

	}

CRtpFlow::~CRtpFlow()

	{

	delete iRtpSession;

	iRtpBuffer.Close();

	LOG_NODE_DESTROY(KESockFlowTag, CRtpFlow);

	}

void CRtpFlow::CanSend()

	{

	__ASSERT_DEBUG(iSessionDataNotify,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicNoControlProvider));

	CRtpBaseFlow::CanSend();

	}

TInt CRtpFlow::Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr )

	{

	TInt nwr = -1;

	TInt ret = KErrNone;

	/* Findout the amount of Data contained in the RMbuf Chain */

	TInt rmbuflen = aData.Length();

	TPtr8 rtpBufPtr(NULL, 0);

	LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tWrite() Len=%d"), this, rmbuflen));

	if(!(aData.First()->Next()))

		{

		RMBuf *buffer = aData.First();

		__ASSERT_DEBUG(rmbuflen == buffer->Length() ,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicIncompleteBuffer));

		rtpBufPtr.Set(buffer->Ptr(), rmbuflen, rmbuflen);

		}

	else

		{

		if(iRtpBuffer.MaxLength() < rmbuflen)

			{

			iRtpBuffer.SetLength(0);

			ret = iRtpBuffer.ReAlloc(rmbuflen);

			if(KErrNone != ret)

				{

				LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tWrite() -ALLOC Failed!"), this));

				/* In case of error a protocol is supposed to Error and then return 0 */

				iSessionControlNotify->Error(ret,MSessionControlNotify::EErrorSend);

				return 0;

				}

			}

		/* Copy the Data from RMbuf to Descriptor. Then Pass it to the RtpStack*/

		iRtpBuffer.SetLength(rmbuflen);

		aData.CopyOut(iRtpBuffer);

		rtpBufPtr.Set(&iRtpBuffer[0], rmbuflen, iRtpBuffer.MaxLength());

		}

	if(!NonRtpSendData())

		{

		iRtpSession->PacketBeingSent(rtpBufPtr, ERtp); 

		}

	//It is assumed that a Properly Created packet is passed down here.

	//Maybe we should handle a return code for PacketbeingSent function.

	if(aData.First()->Next())

		{

		aData.CopyIn(iRtpBuffer);

		}

	__ASSERT_DEBUG(iSSPData,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicNoServiceProvider));

	nwr = iSSPData->Write(aData, aOptions, anAddr);

	LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tWrite() Done nwr=%d"), this,nwr));	

	return nwr;

	}

void CRtpFlow::ReceivedL(const Messages::TRuntimeCtxId& aSender, const Messages::TNodeId& aRecipient, Messages::TSignatureBase& aMessage)

    {

	CRtpBaseFlow::ReceivedL(aSender,aRecipient,aMessage);

    LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tReceivedL() Msg %d"), this, aMessage.MessageId().MessageId()));

	if ( aMessage.IsMessage<Messages::TEBase::TError>() )

		{

        LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tGot TError from Sunconn"), this));

        HandleError(static_cast<Messages::TEBase::TError&>(aMessage).iValue);

		}	

    else if (Messages::TEChild::ERealmId == aMessage.MessageId().Realm())

        {

    	switch (aMessage.MessageId().MessageId())

        	{

   		case Messages::TEChild::TDestroy::EId :

    			{

            	Destroy();

            	break;

    			}

        	}

		}

	else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())

		{

	    switch (aMessage.MessageId().MessageId())

        	{

        	case TCFDataClient::TProvisionConfig::EId:

         		{	

    			TCFDataClient::TProvisionConfig& aMess = Messages::message_cast<TCFDataClient::TProvisionConfig>(aMessage);

				iAccessPointConfig.Close();

				iAccessPointConfig.Open(aMess.iConfig);

				const CRtpProvisionConfig& rtpProv = static_cast<const CRtpProvisionConfig&>(AccessPointConfig().FindExtensionL(STypeId::CreateSTypeId(KRtpProvisionUid, KRtpProvisionConfigType)));

				DoProvisionL(&rtpProv);

				/* Deafult Processing */

				HandleProvisionMessage(aMessage);				

        		break;

         		}

	        case TCFDataClient::TStart::EId :

        		{

	        	/* Check if we Have a Bearer. If we donot Have

	        	   complete when we Have one */

        		User::LeaveIfError(iStartRequest.Open(iSubConnectionProvider,aSender));

	        	if(iSSPData)

	        		{

	        		CompleteStart(KErrNone);

	        		}

	        	else

	        		{

	        		LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tGot TDataClientStart no SP iIsStarting=>ETrue"), this));

	        		iIsStarting = ETrue;		

	        		}

	        	}

	            break;

	         case TCFDataClient::TStop::EId :

	         	{

	        	StopFlow(static_cast<TCFDataClient::TStop&>(aMessage));

	            break;

	         	}

	         case TCFDataClient::TBindTo::EId :

				{

				TCFDataClient::TBindTo& bindToMsg(static_cast<TCFDataClient::TBindTo&>(aMessage));

                TRAPD(err,BindToL(bindToMsg));

                if(err)

                    {

                    Messages::RClientInterface::OpenPostMessageClose(Id(), aSender, Messages::TEBase::TError(TCFDataClient::TBindTo::Id(), err).CRef());

                    }

                else

                    {

                    Messages::RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());

                    }

				//If we have received TDataClientStart before (when we did not yet have a bearer),

				//we complete the start here as well

				if (iIsStarting)

					{

					CompleteStart(err);

					}

				HandleBindToMessage(aMessage,err);	

                break;			

				}

        	}

		}

	else if (TCFControlProvider::ERealmId == aMessage.MessageId().Realm())

		{

		/* VRAMY : LOG Here!!! */

		}

	}

void CRtpFlow::DoProvisionL(const CRtpProvisionConfig *apRtpProv)    

	{

	iRtpSession->SetSessionBandwidth(apRtpProv->BandWidth());

	iRtpSession->SetRTPTimeConversion(apRtpProv->RtpTimeNow(),apRtpProv->RtptimeConversion());

	iRtpSession->SetRtpStreamParameters(apRtpProv->MaxDropOut(),

										apRtpProv->MaxMisorder(),

										apRtpProv->MinSequential());

	}

TInt CRtpFlow::GetData(RMBufChain& aData, TUint aLength, TUint aOptions, TSockAddr* anAddr)

	{

	ASSERT(iSSPData);

	TInt ret;

	LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tGetData "), this ));

	ret = iSSPData->GetData(aData, aLength, aOptions, anAddr);

	if(ret < 0)

		{

		/* The Read failed. Just pass the error up */

		LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tGetData failed (ret =%d)"), this));

		return ret;

		}

	/* Findout the amount of Data contained in the RMbuf Chain */

	TInt rmbuflen = aData.Length();

	TPtr8 rtpBufPtr(NULL, 0);

	if(!(aData.First()->Next()))

		{

		RMBuf *buffer = aData.First();

		__ASSERT_DEBUG(rmbuflen == buffer->Length() ,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicIncompleteBuffer));

		rtpBufPtr.Set(buffer->Ptr(), rmbuflen, rmbuflen);

		}

	else

		{

		if(iRtpBuffer.MaxLength() < rmbuflen)

			{

			iRtpBuffer.SetLength(0);

			ret = iRtpBuffer.ReAlloc(rmbuflen);

			if(KErrNone != ret)

				{

				return ret;

				}	

			}

		iRtpBuffer.SetLength(rmbuflen);

		aData.CopyOut(iRtpBuffer);

		rtpBufPtr.Set(&iRtpBuffer[0], rmbuflen, iRtpBuffer.MaxLength());

		}

	if(anAddr)

		{

		iRtpHandler->SetRecvAddress(*anAddr);

		}

	else

		{

		/* Connected Socket */

		__ASSERT_DEBUG(iConnected,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicIncorrectState));

		iRtpHandler->SetRecvAddress(iDestAddr);

		}

	TRAP(ret,iRtpSession->DoReceiveL(rtpBufPtr,ERtp));

	if((KErrNone == ret) && (aData.First()->Next()))

		{

		aData.CopyIn(iRtpBuffer);

		}

	LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tGetData()) done ret=%d"), this,ret));

	return ret;

	}

void CRtpFlow::SendData(TDes8& , TSockAddr &, TInt , TRequestStatus  &aStatus)

	{

		TRequestStatus *stat = &aStatus;

		User::RequestComplete(stat,KErrNone);

	}

void CRtpFlow::NewData(TUint aCount)

	{

	__ASSERT_DEBUG(iSessionDataNotify,User::Panic(KRtpFlowPanic, RtpFlowPanics::KPanicNoControlProvider));

	LOG( ESockLogExternal::Printf(KESockFlowTag,KRtpFlowSubTag,_L8("CRtpFlow %08x:\tNewData()"), this));

	CRtpBaseFlow::NewData(aCount);

	}

/* When an RTCP flow is created call this function to enable RTCP in

   RtpSession. The function will return a Pointer to RTPSession which

   can be passed on to RTCP Flow */

CRtpController* CRtpFlow::GetRtpSession() const

	{

	return 	iRtpSession;

	}

void CRtpFlow::DoCanClose(MSessionControlNotify::TDelete )

/**

Called from protocol to indicate that a graceful close has completed

*/

	{

	/* RTP Session is no longer Valid and Can be Closed now */

	/* OOPS no API to close the RtpSession :(*/

	}

void CRtpFlow::DoUpdateLocalAddress(const TSockAddr& anAddr)

/* Called by BaseFlow to notify that Local address has been 

   Updated. Ideally called only once */

	{

	iRtpSession->SetLocalAddress(anAddr);

	}

TInt CRtpFlow::DoGetOption(TUint level, TUint name, TDes8 &aOption) const

	{

	/* Socket option for RTP */

	if(KSolRtp == level)

		{

		switch(name)

			{

			case KSoLocalSSRC:

				{

				TUint locSSRC = iRtpSession->GetLocalSSRC();

				CopyOptionToDesc(aOption,locSSRC);

				break;

				}

			default:

				{

				return KErrNotSupported;

				}

			}

		return KErrNone;

		}

	if(iSSP)

	 return iSSP->GetOption(level,name,aOption);

	return KErrNone;

	}

TInt CRtpFlow::DoSetOption(TUint level, TUint name, const TDesC8 &aOption)

	{

	/* Socket option for RTP */

	if(KSolRtp == level)

		{

		TInt ret = KErrNone;

		switch(name)

			{

			case KSoRtpBandwidth:

				{

				TInt optInt=0;

				GETOPTION_OR_RETURN(aOption,optInt);

				iRtpSession->SetSessionBandwidth(optInt);

				break;

				}

			case KSoStreamParams:

				{

				TRtpStreamParams strmParams;

				GETOPTION_OR_RETURN(aOption,strmParams);

				iRtpSession->SetRtpStreamParameters(strmParams.iMaxDropout,

						                            strmParams.iMaxMisorder,

						                            strmParams.iMinSequential);

				break;

				}

			case KSoRtpTimeConvertion:

				{

				TRtpTimeConversion rtpTimeConv;

				GETOPTION_OR_RETURN(aOption,rtpTimeConv);

				iRtpSession->SetRTPTimeConversion(rtpTimeConv.iRtpTimeNow,

												  rtpTimeConv.iConversion);

				break;

				}

			case KSoSendNonRtpData:

				{

				TInt nonRtpData = 0;

				GETOPTION_OR_RETURN(aOption,nonRtpData);

				SetNonRtpSendData(nonRtpData);

				break;	

				}

			case KSoReceiveNonRtpData:

				{

				TInt nonRtpData = 0;

				GETOPTION_OR_RETURN(aOption,nonRtpData);

				iRtpSession->SetNonRtpData(nonRtpData);

				break;	

				}

			case KSoSamplingRate:

				{

				TSamplingRateInfo sampRateInfo;

				GETOPTION_OR_RETURN(aOption,sampRateInfo);

				ret = iRtpSession->SetSamplingRate(sampRateInfo.iPayloadType,

											 sampRateInfo.iSamplingRate);

				break;

				}

			default:

				{

				return KErrNotSupported;

				}

			}

		return ret;

		}

	if(iSSP)

		return iSSP->SetOption(level,name,aOption);

	return KErrNone;

	}

void CRtpFlow::SetNonRtpSendData(TInt aNonRtpData)

	{

	iNonRtpSendData = aNonRtpData;

	}

TInt CRtpFlow::NonRtpSendData()

	{

	return iNonRtpSendData;

	}