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

// class for the rtpwrapper unit test cases

// 

//

/**

 @file

*/

#include <e32math.h>

#include <commdbconnpref.h> 

#include <rtp.h>

#include <rtcp.h>

#include <COMMDB.H> 

#include <srtpsession.h>

#include "rtpheader.h"

#include "rtpmanager.h"

TInt RtpSessionLinearOrderFunc(const  CRtpSessionInfo& aNew, const CRtpSessionInfo &aArrElem)

	{

	return aNew.iPortNumber - aArrElem.iPortNumber;

	}

CRtpSessionInfo* CRtpSessionInfo::NewL()

	{

	LOG_FUNC_ENTRY("CRtpSessionInfo::NewL");

	CRtpSessionInfo *self = new(ELeave) CRtpSessionInfo();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	LOG_FUNC_EXIT("CRtpSessionInfo::NewL");

	return self;

	}

void CRtpSessionInfo::ConstructL()

	{

	LOG_FUNC_ENTRY("CRtpSessionInfo::ConstructL");

	}

/* Creates a CrtpManager object */

CRtpManager* CRtpManager::NewL(MRtpErrNotify& aErrNotify )

	{

	LOG_FUNC_ENTRY("CRtpManager::NewL");

    CRtpManager *self = new(ELeave) CRtpManager();

	CleanupStack::PushL(self);

	self->ConstructL(aErrNotify);

	CleanupStack::Pop();

	LOG_FUNC_EXIT("CRtpManager::NewL");

	return self;

	}

CRtpManager::CRtpManager( )

	{

	LOG_FUNC_ENTRY("CRtpManager::CRtpManager");

	iOwnsConnection   = EFalse;

	iOwnsSocketServer = EFalse;

	LOG_FUNC_EXIT("CRtpManager::CRtpManager");

	}

CRtpManager::~CRtpManager( )

	{

	LOG_FUNC_ENTRY("CRtpManager::~CRtpManager");

	Close();

	/* Clean up the Arrays */

	iRtpSessionArr.Close();

	iRtpStreamsArr.Close();

	if(iOwnsConnection)

		delete iConnection;

	if(iOwnsSocketServer)

		delete iSocketServ;

	LOG_FUNC_EXIT("CRtpManager::~CRtpManager");

	}

void CRtpManager::ConstructL(MRtpErrNotify& aErrNotify )

	{

	LOG_FUNC_ENTRY("CRtpManager::ConstructL");

	iRtpErrNotify = &aErrNotify;

	LOG_FUNC_EXIT("CRtpManager::ConstructL");

	}

TInt CRtpManager::OpenL( const TRtpSdesParams& aSdesInfo,  const TDesC* aRtpPacketDll,

                         const RSocketServ* aSocketServPtr, const RConnection* aConnPtr )

	{

	LOG_FUNC_ENTRY("CRtpManager::OpenL");

	/* The current implementation do not support having a different

	 * aRtpPacketDll

	 * So the argument is ignored */

	(void)aRtpPacketDll;

	if(aSocketServPtr)

		{

		iSocketServ = const_cast<RSocketServ*>(aSocketServPtr);

		}

	else

		{

		iSocketServ = new(ELeave) RSocketServ();

		iOwnsSocketServer = ETrue;

		}

	if(aConnPtr)

		{

		iConnection = const_cast<RConnection*>(aConnPtr);

		}

	else

		{

		iConnection = new(ELeave) RConnection();

		iOwnsConnection = ETrue;

		}

	iSdesInfo  = aSdesInfo;

	User::LeaveIfError(iSocketServ->Connect());

	User::LeaveIfError(iConnection->Open(*iSocketServ));

	LOG_FUNC_EXIT("CRtpManager::OpenL");

	return KErrNone;

	}

 /**

  * Open and initialize the CRtpAPI object.

  * @param aIapId - [input] IAP ID. If -1, no IAP selection dialog

  *   will pop up. Instead, the default IAP will be used.

  * @return KErrNone if successful; system wide error code otherwise

 */

TInt CRtpManager::StartConnection( TInt aIapId )

	{

	LOG_FUNC_ENTRY("CRtpManager::StartConnection");

	__RTP_LOG1("IapId = %d",aIapId)

	if(aIapId != -1)

		{

		TCommDbConnPref prefs;

		prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

		prefs.SetDirection(ECommDbConnectionDirectionOutgoing);

		prefs.SetIapId(aIapId);

		iIapId = aIapId;

		return iConnection->Start(prefs);

		}

	else

		{

		TRAPD(err,iIapId = GetDefaultIapIdL());

		if(KErrNone != err)

			{

			__RTP_LOG1("GetDefaultIapIdL returned  %d",err)

			return err;

			}

		__RTP_LOG1("GetDefaultIapIdL default Iap:  %d",iIapId)

		LOG_FUNC_EXIT("CRtpManager::StartConnection");

		return iConnection->Start();

		}

	}

TInt CRtpManager::StartConnection( TRequestStatus& aStatus, TInt aIapId)

	{

	LOG_FUNC_ENTRY("CRtpManager::StartConnection-Async");

	__RTP_LOG1("aIapId = %d",aIapId);

	TCommDbConnPref prefs;

	prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

	prefs.SetDirection(ECommDbConnectionDirectionOutgoing);

	if(aIapId != -1)

		{

		prefs.SetIapId(aIapId);	

		iConnection->Start(prefs, aStatus);

		iIapId = aIapId;

		}

	else

		{

		TRAPD(err,iIapId = GetDefaultIapIdL());

		if(KErrNone != err)

			{

			__RTP_LOG1("GetDefaultIapIdL returned  %d",err)

			return err;

			}

		__RTP_LOG1("GetDefaultIapIdL default Iap:  %d",iIapId)

		prefs.SetIapId(iIapId);

		iConnection->Start(prefs, aStatus);

		}

	LOG_FUNC_EXIT("CRtpManager::StartConnection-Async");

	return KErrNone;

	}

/**

* Cancels asynchoronous start of connection.

* Any open requests will be completed with KErrCancel.

* @return None

*/

void CRtpManager::CancelStart()

	{

	LOG_FUNC_ENTRY("CRtpManager::CancelStart");

	return;

	}

void CRtpManager::Close()

	{

	LOG_FUNC_ENTRY("CRtpManager::Close");

	/* Iterate through the session array and close */

	for(int i=0; i < iRtpSessionArr.Count(); i++)

		{

		__RTP_LOG1("Closing Session Key %u",iRtpSessionArr[i]->iKey);

		iRtpSessionArr[i]->iRtpSession.Close();

		ASSERT(iRtpSessionArr[i]->iPendingReqQue->IsEmpty());

		delete iRtpSessionArr[i]->iPendingReqQue;

		iRtpSessionArr[i]->iPendingReqQue = NULL;

		}

	if(iConnection)

		iConnection->Close();

	if(iSocketServ)

		iSocketServ->Close();

	LOG_FUNC_EXIT("CRtpManager::Close");

	}

/**

* Set SDES (Source Description) information of the local participant.

* Participant is defined as an application program and

* only one local participant is allowed.

*/

 void CRtpManager::SetLocalSdes( const TRtpSdesParams& aSDES)

	{

	/* Should the SDES list be updated again here ? */

	LOG_FUNC_ENTRY("CRtpManager::SetLocalSdes");

	iSdesInfo = aSDES;

	}

/**

* Get the local IP address

* @param None

* @return local ip address.

*/

 TInetAddr& CRtpManager::GetLocalIPAddressL()

	{

	LOG_FUNC_ENTRY("CRtpManager::GetLocalIPAddressL");

	/* Open an RSocket and find its address */

	RSocket socket;

	User::LeaveIfError(socket.Open(*iSocketServ, KAfInet, KSockDatagram, KProtocolInetUdp,*iConnection));

	CleanupClosePushL(socket);

	TSoInetInterfaceInfo networkInfo;

	TPckg<TSoInetInterfaceInfo> opt(networkInfo);

	User::LeaveIfError(socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl));

	TSoInetIfQuery query;

	TPckg<TSoInetIfQuery> queryBuf(query);

	TInt res = KErrNone;

	do 

	{

		res = socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt);

		if (!res && opt().iState == EIfUp)

		{

			query.iName = opt().iName;

			res = socket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, queryBuf);

			if (!res && query.iZone[1] == iIapId)

			{

				networkInfo = opt();

				break;

			}

		}

	}

	while (res == KErrNone);

    if(res!= KErrNone)

    	{

    	__RTP_LOG1("Found nothing! ret %d",res)

    	/* Didn't find :( */

    	User::Leave(res);

    	}

	CleanupStack::PopAndDestroy(1);

    iSockAddr = networkInfo.iAddress;

    LOG_FUNC_EXIT("CRtpManager::GetLocalIPAddressL");

	return iSockAddr;

	}

 /**

 * Makes a CName that is unique for a given seesion 

 */

void CRtpManager::MakeACnameL(TDes8 &aCname)

	{

	/* As of now putting the IP Address. But this is not enough.

	 * multiple sessions should have unique CNAMES 

	 * */

	TBuf<50> ipAddr;

	TInetAddr locAddr = GetLocalIPAddressL();

	locAddr.Output(ipAddr);

	aCname.Format(_L8("%d@"),iRtpSessionArr.Count()+1);

	aCname.Append(ipAddr);

	}

/**

* Create a new RTP Session and return the Session ID as well as the

* local port number assigned for RTP. RTP uses an even port number and

* RTCP, if enabled, uses the next higher (odd) port number.

*/

 TRtpId CRtpManager::CreateSessionL(const TCreateSessionParams& aSessionParams,

                           	                TUint& aPort, TBool aEnableRtcp, const TRtcpParams* aRtcpParams )

	{

	LOG_FUNC_ENTRY("CRtpManager::CreateSessionL");

	__RTP_LOG1("RTCP stat %d",aEnableRtcp)

	TInt localPort;

	/* The RTP Session create takes in the LocalPort.*/

	if(iRtpSessionArr.Count() == 0)

		{

		//In this case start from begining. Start by using the default Even RTP

		//Port.

		localPort = KDefaultStartRtpAddress;

		__RTP_LOG1("LocalPort used %d",localPort)

		}

	else

		{

		/* Pick the next highest port number */

		localPort = iRtpSessionArr[iRtpSessionArr.Count()-1]->iPortNumber + 2;

		__RTP_LOG1("LocalPort used %d",localPort)

		}

	//if the user has specified a port then override our selection

	if(aPort)

		{

		localPort = aPort;

		}

	//Now use this Port and try opening the RTP Session. If the Session Open

	//fails try opening with the next even port.

    //Its much more easier to use the API which takes RSocket directly here. But

	//ths would mean we cannot use the New CFRTP API.

	TInetAddr locAddr(0,localPort);

	/* Remote address is uninitialized. Unfortunately its required by Symbian

	 * RTP stack. */

	TInetAddr remAddr;

	#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

	RRtpSession rtpSession;

	#else

	RRtpSession_Internal rtpSession;

	#endif	

	TPtrC8 cnameTptr((TUint8*)"", 0);;

	if(aEnableRtcp)

		{

		TBuf8<50> cnameBuf;

		if(iSdesInfo.iCName == KNullDesC8)

			{

			MakeACnameL(cnameBuf);

			iSdesInfo.iCName.Set(cnameBuf);

			}

		cnameTptr.Set(iSdesInfo.iCName);

		}

	else

		{

		cnameTptr.Set(KNullDesC8);

		}

	TInt tryCount = 0;

	TInt errOpenl = KErrNone;

	__RTP_LOG1("Starting Port alloc and OpenL tryCount %d",tryCount);

	__RTP_LOG1("aSessionParams.iSocketBufSize    %d",aSessionParams.iSocketBufSize);	

   aPort = locAddr.Port();

    while(tryCount < 5 )

		{

    	TRAP(errOpenl,rtpSession.OpenL(*iSocketServ, locAddr, remAddr, aSessionParams.iSocketBufSize, *iConnection, EPriorityNormal, cnameTptr));

		if(errOpenl != KErrNone)

			{

			__RTP_LOG2("OpenL Failed with Error Code %d TryCount %d",errOpenl, tryCount);

			tryCount ++;

			locAddr.SetPort(locAddr.Port()+tryCount+1);

			localPort += tryCount+1;

			}

		else

			{

			break;

			}

		}

    User::LeaveIfError(errOpenl);

	__RTP_LOG(",rtpSession.OpenL Success!!");

	TTimeIntervalMicroSeconds32 rtcpInterval;

	if(aEnableRtcp && aRtcpParams)

		{

		rtpSession.SetBandwidth(aRtcpParams->iSessionBWidth);

		__RTP_LOG1(" aRtcpParams->iRtcpTimeOut %d", aRtcpParams->iRtcpTimeOut.Int());

		if(aRtcpParams->iRtcpTimeOut.Int())

		    {

			rtcpInterval = aRtcpParams->iRtcpTimeOut.Int();

		    }

		else

		    {

		    //TODO fix me!

		    //default 500 ms

		    rtcpInterval = 1000000;

		    }

        rtpSession.SetRtcpInterval(rtcpInterval);

		}

	else

		{

		__RTP_LOG("Setting default RTCP Properties!!");

		//Default Bandwidth.

		rtpSession.SetBandwidth(KRtpDefaultBandWidth);	

		rtcpInterval = 1000000;

		rtpSession.SetRtcpInterval(rtcpInterval);

		}

	//Phew! Now put these in our Array

	CRtpSessionInfo* sessionInfo = CRtpSessionInfo::NewL();

	//Assign a Key for this session.

	sessionInfo->iKey         = Math::Random();

	sessionInfo->iPortNumber  = localPort;

	sessionInfo->iRtpSession  = rtpSession;

	sessionInfo->iRtpManager  = this;

	sessionInfo->iRtcpEnabled = aEnableRtcp;

	sessionInfo->iPendingReqQue = new(ELeave)  TSglQue<TRtpSendReqNode>(_FOFF(TRtpSendReqNode,iLink));

	iRtpSessionArr.InsertInOrder(sessionInfo, TLinearOrder<CRtpSessionInfo>(RtpSessionLinearOrderFunc)); //InsertInOrder(sessionInfo,TLinearOrder<CRtpSessionInfo>(RtpSessionLinearOrderFunc));

	__RTP_LOG1("Session Created Key %u",sessionInfo->iKey)

    //Get back the reference to the object in Array.

	TInt idx = FindSessionL(sessionInfo->iKey);

    //Register for the Events  

	RegisterEventsOnSessionL(iRtpSessionArr[idx]);

	aPort = localPort;

	//TODO: Fix this in RTP Stack.

	/* Remote Address is uninitialized now. So if RTCP is enabled disable autosend so that

	 * no data is send to incorrect address.

	 */

	if(aEnableRtcp)

		{

		rtpSession.SetRTCPAutoSend(EFalse);

		}

	LOG_FUNC_EXIT("CRtpManager::CreateSessionL");

	return sessionInfo->iKey;

	}

/**

 *Create a new, secure RTP Session and return the Session ID as well as the

* local port number assigned for RTP. RTP uses an even port number and

* RTCP, if enabled, uses the next higher (odd) port number.

* User is expected to create corresponding SRTP session prior to calling this

* function. 

*/

 TRtpId CRtpManager::CreateSessionL( const TCreateSessionParams& aSessionParams, TUint& aPort, 

	                				TBool aEnableRtcp, const TRtcpParams* aRtcpParams, CSRTPSession& aSRTPSession)

	{

	LOG_FUNC_ENTRY("CRtpManager::CreateSessionL");

	__RTP_LOG("SRTP is not supported Leaving..!!")

	TUint32 key = CreateSessionL(aSessionParams, aPort, aEnableRtcp, aRtcpParams);

	TInt idx = FindSessionL(key);

	iRtpSessionArr[idx]->iSRTPSession = &aSRTPSession;

	iRtpSessionArr[idx]->iRtpSession.SetPrePostProcessingRegisterCallback(iRtpSessionArr[idx]);

	return key;

	}

/**

* Start an RTP Session. If enabled, RTCP associated with the given

* session is also started.

*/

 TInt CRtpManager::StartSession( TRtpId aSessionId )

	{

	LOG_FUNC_ENTRY("CRtpManager::StartSession");

	if(FindSession(aSessionId)!= KErrNotFound)

		{

		/* Well we found the session. But Really nothing to do */

		//TODO verify

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

/**

* Close an RTP Session.

*/

 void CRtpManager::CloseSession( TRtpId aSessionId )

	{

	LOG_FUNC_ENTRY("CRtpManager::CloseSession");

	__RTP_LOG1("SessID %u",aSessionId)

	TInt idx;

	idx = FindSession(aSessionId);

	if(KErrNotFound != idx)

		{

		/* This takes care of all cleaning up */

		iRtpSessionArr[idx]->iRtpSession.Close();

		/* There should be no more Pending requests on this session */

		ASSERT(iRtpSessionArr[idx]->iPendingReqQue->IsEmpty());

		delete iRtpSessionArr[idx]->iPendingReqQue;

		CRtpSessionInfo *session = iRtpSessionArr[idx];

		iRtpSessionArr.Remove(idx);

		delete session;

		}

	else

		{

		__RTP_LOG("Session not found")

	    //So already cleaned?	

		}