// 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: THIS FILE IS A PROTOTYPE AND IS NOT MEANT TO BE USED IN PRODUCTION CODE

// 

//

#include "rtpapi.h"

#include "rtpmanager.h" 

/**

* Two-phased constructor.

*/

EXPORT_C CRtpAPI* CRtpAPI::NewL( MRtpErrNotify& aErrNotify )

	{

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

	CleanupStack::PushL(self);

    self->ConstructL(aErrNotify);

    CleanupStack::Pop();

    return self;

	}

CRtpAPI::~CRtpAPI()

	{

	delete iManager;

	}

EXPORT_C TInt CRtpAPI::OpenL( const TRtpSdesParams& aSdesInfo,

					const TDesC* aRtpPacketDll,

					const RSocketServ* aSocketServPtr,

					const RConnection* aConnPtr )

	{

	return iManager->OpenL(aSdesInfo,aRtpPacketDll, aSocketServPtr, aConnPtr);

	}

EXPORT_C TInt CRtpAPI::StartConnection( TInt aIapId  )

	{

	return iManager->StartConnection(aIapId);

	}

EXPORT_C TInt CRtpAPI::StartConnection( TRequestStatus& aStatus,TInt aIapId )

	{

	return iManager->StartConnection(aStatus, aIapId);

	}

/**

* Cancels asynchoronous start of connection.

* Any open requests will be completed with KErrCancel.

* @return None

*/

EXPORT_C void CRtpAPI::CancelStart()

	{

	iManager->CancelStart();

	return;

	}		

/**

* Close the CRtpAPI object.

*/

EXPORT_C void CRtpAPI::Close()

	{

	iManager->Close();

	return;

	}

/**

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

* Participant is defined as an application program and

* only one local participant is allowed.

*/

EXPORT_C void CRtpAPI::SetLocalSdes( const TRtpSdesParams& aSdesInfo )

	{

	iManager->SetLocalSdes(aSdesInfo);

	}

/**

* Get the local IP address

* @param None

* @return local ip address.

*/

EXPORT_C TInetAddr& CRtpAPI::GetLocalIPAddressL()

	{

	return iManager->GetLocalIPAddressL();

	}

/**

* 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.

*/

EXPORT_C TRtpId CRtpAPI::CreateSessionL(const TCreateSessionParams& aSessionParams,

										TUint& aPort,

										TBool aEnableRtcp,

										const TRtcpParams* aRtcpParams )

	{

	return iManager->CreateSessionL(aSessionParams, aPort, aEnableRtcp, aRtcpParams);

	}

/**

* 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. 

*/

EXPORT_C TRtpId CRtpAPI::CreateSessionL( 

	                const TCreateSessionParams& aSessionParams, 

	                TUint& aPort, 

	                TBool aEnableRtcp, 

	                const TRtcpParams* aRtcpParams, 

	                CSRTPSession& aSession)

	{

	return iManager->CreateSessionL(aSessionParams, aPort, aEnableRtcp, aRtcpParams, aSession);

	}

/**

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

* session is also started.

*/

EXPORT_C TInt CRtpAPI::StartSession( TRtpId aSessionId )

	{

	return iManager->StartSession(aSessionId);

	}

/**

* Close an RTP Session.

*/

EXPORT_C void CRtpAPI::CloseSession( TRtpId aSessionId )

	{

	iManager->CloseSession(aSessionId);

	return;

	}

/**

* Set remote IP address and port number to RTP Session.

* Port number for RTP must be an even number and the corresponding

* RTCP, if enabled, will be set to use the next higher (odd) port.

*/

EXPORT_C TInt CRtpAPI::SetRemoteAddress( TRtpId aSessionId,const TInetAddr& aRemoteAddr )

	{

	return iManager->SetRemoteAddress(aSessionId, aRemoteAddr);

	}

/**

* Set remote RTCP IP address and port number to RTP Session accoring to RFC 3605

* i.e. this should be used if RTCP port is different than RTP port + 1

*/

EXPORT_C TInt CRtpAPI::SetRemoteRtcpAddress( TRtpId aSessionId, const TInetAddr& aRemoteRtcpAddr )

	{

	return iManager->SetRemoteRtcpAddress(aSessionId, aRemoteRtcpAddr);

	}

/**

* Create a Receive stream for an RTP Session and return the stream

* ID which is unique for all RTP Sessions.

*/

EXPORT_C TRtpId CRtpAPI::CreateReceiveStreamL( TRtpId aSessionId,const TRcvStreamParams& aParams )

	{

	return iManager->CreateReceiveStreamL(aSessionId, aParams);

	}

/**

* Create a Transmit stream for an RTP Session and return the stream

* ID which is unique for all RTP Sessions. SSRC value assigned for the

* very first Transmit stream will be the same as the default SSRC

* value reserved internally by CreateSession function. This function

* is normally used to create a transmit stream where SSRC value is

* randomly generated.

*/

EXPORT_C TRtpId CRtpAPI::CreateTransmitStreamL( TRtpId aSessionId, const TTranStreamParams& aParams, TRtpSSRC& aSSRC )

	{

	return iManager->CreateTransmitStreamL(aSessionId,aParams,aSSRC);

	}

/**

* Create a Transmit stream, with a given SSRC value, for an RTP Session

* and return the stream ID which is unique for all RTP Sessions. This

* extended function is used for a special case where a specific SSRC

* value needs to be associated with the transmit stream being created,

* e.g. for retransmission purpose.

*/

EXPORT_C TRtpId CRtpAPI::CreateTransmitStreamExtL( TRtpId aSessionId, const TTranStreamParams& aParams, const TRtpSSRC aSSRC )

	{

	return iManager->CreateTransmitStreamExtL(aSessionId, aParams, aSSRC);

	}

/**

* Close a Transmit or Receive stream.

*/

EXPORT_C void CRtpAPI::CloseStream( TRtpId aStreamId )

	{

	iManager->CloseStream(aStreamId);

	return;

	}

/**

* Register a callback object for receiving RTP data packets from an RTP

* Session. Only one receiver callback object is allowed to be

* registered for one Session.

* MRtpObserver::RtpPacketReceived function from aRtpObserver object is

* called when an RTP data packet is received.

*/

EXPORT_C TInt CRtpAPI::RegisterRtpObserver( TRtpId aSessionId, MRtpObserver& aRtpObserver )

	{

	return iManager->RegisterRtpObserver(aSessionId, aRtpObserver);

	}

/**

* Unregister RTP observer callback object associated with an RTP

* session.

*/

EXPORT_C void CRtpAPI::UnregisterRtpObserver( TRtpId aSessionId )

	{

	iManager->UnregisterRtpObserver(aSessionId);

	}

/**

* Sets/resets the observer for the non-RTP data.

* Only one receiver callback object is allowed to be

* registered for one Session.

*/

EXPORT_C TInt CRtpAPI::SetNonRTPDataObserver( TRtpId aSessionId, MNonRTPDataObserver* aNonRTPDataObserver )

	{

	return iManager->SetNonRTPDataObserver(aSessionId, aNonRTPDataObserver);

	}

/**

* Send an RTP data packet in a Transmit stream synchronously.

*/

EXPORT_C TInt CRtpAPI::SendRtpPacket( TRtpId aTranStreamId, const TRtpSendHeader& aHeaderInfo,

							const TDesC8& aPayloadData )

	{

	return iManager->SendRtpPacket(aTranStreamId, aHeaderInfo, aPayloadData);

	}

/**

* Send an RTP data packet in a Transmit stream asynchronously.

*/

EXPORT_C TInt CRtpAPI::SendRtpPacket( TRtpId aTranStreamId, const TRtpSendHeader& aHeaderInfo, const TDesC8& aPayloadData,

							 TRequestStatus& aStatus )

	{

	return iManager->SendRtpPacket(aTranStreamId, aHeaderInfo, aPayloadData, aStatus);

	}

/**

* Send an RTP data packet asynchronously, with a given sequence number,

* in a Transmit stream mainly for retransmission purpose.

*/

EXPORT_C TInt CRtpAPI::SendRtpPacket( TRtpId aTranStreamId, TRtpSequence aSequenceNum, const TRtpSendHeader& aHeaderInfo,

									  const TDesC8& aPayloadData, TRequestStatus& aStatus )

	{

	return iManager->SendRtpPacket(aTranStreamId, aSequenceNum, aHeaderInfo, aPayloadData, aStatus);

	}

/**

* Send a non-RTP (control) data packet asynchronously

*/

EXPORT_C void CRtpAPI::SendDataL( TRtpId aSessionId, TBool aUseRTPSocket, const TDesC8& aData, TRequestStatus& aStatus )

	{

	iManager->SendDataL(aSessionId, aUseRTPSocket, aData, aStatus);

	}

/**

* Cancel an outstanding SendRtpPacket() operation.

*/

EXPORT_C void CRtpAPI::CancelSend( TRtpId aSessionId )

	{

	iManager->CancelSend(aSessionId);

	return;

	}

/**

* Register a callback object for receiving RTCP packets associated with

* a given RTP Session. Only one observer callback object is allowed to

* be registered. One of aRtcpObserver object's callback functions is

* called when an RTCP packet of that type is received.

*/

EXPORT_C TInt CRtpAPI::RegisterRtcpObserver( TRtpId aSessionId, MRtcpObserver& aRtcpObserver )

	{

	return iManager->RegisterRtcpObserver(aSessionId, aRtcpObserver);

	}

/**

* Unregister RTCP observer callback object associated with an RTP

* session.

*/

EXPORT_C void CRtpAPI::UnregisterRtcpObserver( TRtpId aSessionId )

	{

	iManager->UnregisterRtcpObserver(aSessionId);

	return;

	}

/**

* Send an RTCP BYE packet for a Transmit stream.

*/

EXPORT_C TInt CRtpAPI::SendRtcpByePacket( TRtpId aTranStreamId, const TDesC8& aReason )

	{

	return iManager->SendRtcpByePacket(aTranStreamId, aReason);

	}

/**

* Send an RTCP APP packet for a Transmit stream.

*/

EXPORT_C TInt CRtpAPI::SendRtcpAppPacket( TRtpId aTranStreamId, const TRtcpApp& aApp )

	{

	return iManager->SendRtcpAppPacket(aTranStreamId, aApp);

	}

/** 

* Send an RTCP RR packet for a Reception stream.

*/

EXPORT_C TInt CRtpAPI::SendRtcpRrPacket( TRtpId aRcvStreamId )

	{

	return iManager->SendRtcpRrPacket(aRcvStreamId);

	}

/** 

* Send an RTCP SR packet for a Transmit stream.

*/

EXPORT_C TInt CRtpAPI::SendRtcpSrPacket( TRtpId aTranStreamId )

	{

	return iManager->SendRtcpSrPacket(aTranStreamId);

	}

		/** 

* Suspend RTCP sending on/off, calculations will continue. 

*/

EXPORT_C TInt CRtpAPI::SuspendRtcpSending( TRtpId aSessionId, TBool aAutoSending )

	{

	return iManager->SuspendRtcpSending(aSessionId, aAutoSending);

	}

/** 

* Gets the status of automatic RTCP sending.

*/

EXPORT_C TInt CRtpAPI::IsRtcpSendingSuspended( TRtpId aSessionId, TBool& aAutoSending )

	{

	return iManager->IsRtcpSendingSuspended(aSessionId, aAutoSending);

	}

/**

* Get the session ID of a stream, which belongs to that session.

*/

EXPORT_C TRtpId CRtpAPI::GetSessionId( TRtpId aStreamId )

	{

	return iManager->GetSessionId(aStreamId);

	}

/**

* Get address of Socket object used by a given RTP Session

* to send/receive RTP data packets.

*/

EXPORT_C RSocket* CRtpAPI::GetRtpSocket( TRtpId aSessionId )

	{

	return iManager->GetRtpSocket(aSessionId);

	}

/**

* Get address of Socket object used by a given RTP Session

* to send/receive RTCP control packets.

*/

EXPORT_C RSocket* CRtpAPI::GetRtcpSocket( TRtpId aSessionId )

	{

	return iManager->GetRtcpSocket(aSessionId);

	}

/**

* Retrieve statistical information for a stream

* based on the reports from RTCP SR & RR packets.

*/

EXPORT_C TInt CRtpAPI::GetStreamStatistics( TRtpId aStreamId, TRtpPeerStat& aStat )

	{

	return iManager->GetStreamStatistics(aStreamId, aStat);

	}

/**

* Get sampling rate setting for a payload type.

*/

EXPORT_C TUint32 CRtpAPI::GetSamplingRate( TUint8 aPayloadType )

	{

	return iManager->GetSamplingRate(aPayloadType);

	}

/**

* Set sampling rate for a payload type.

*/

EXPORT_C TInt CRtpAPI::SetSamplingRate( TUint8 aPayloadType, TUint32 aSamplingRate )

	{

	return iManager->SetSamplingRate(aPayloadType, aSamplingRate);

	}

/**

* Set RTCP parameters for a given RTP Session.

* This function does nothing if RTCP was not enabled previously.

*/

EXPORT_C TInt CRtpAPI::SetRtcpParameters( TRtpId aSessionId, const TRtcpParams& aRtcpParams )

	{

	return iManager->SetRtcpParameters(aSessionId, aRtcpParams);

	}

/**

* Synchronous custom command interface for future extensions.

* Input/output data and return value are defined by each custom command

*/

EXPORT_C TInt CRtpAPI::CustomCommandSync( TInt aFunction, const TDesC8& aInputData1, const TDesC8& aInputData2,

								 TDes8& aOutputData )

	{

	return iManager->CustomCommandSync(aFunction, aInputData1, aInputData2, aOutputData);	

	}

/**

* ASynchronous custom command interface for future extensions.

* Input/output data and return value are defined by each custom command

*/

EXPORT_C TInt CRtpAPI::CustomCommandAsync( TInt aFunction, const TDesC8& aInputData1, const TDesC8& aInputData2, TDes8& aOutputData,

								           TRequestStatus& aStatus )

	{

	return iManager->CustomCommandAsync(aFunction, aInputData1, aInputData2, aOutputData, aStatus);

	}

/**

* Version of RtpService.dll

* @return Version of current RtpService.dll

*/

EXPORT_C TVersion CRtpAPI::Version() const

	{

	return TVersion(0,1,1008);

	}

/**

* C++ default constructor.

*/

CRtpAPI::CRtpAPI()

	{

	}

/**

* By default Symbian 2nd phase constructor is private.

*/

void CRtpAPI::ConstructL( MRtpErrNotify& aErrNotify )

	{

	iManager = CRtpManager::NewL(aErrNotify);

	}