socketudp.cpp

symbian平台S60_2nd_FP2_SC rtp实现

/************************************************************************/
/* This SocketEngine only                                                                     */
/************************************************************************/

#include "socketudp.h"
#include "Writerudp.h"
#include "Readerudp.h"
#include "VTypes.h"
#include "RtpTools.h"

#include "RtpReceiver.h"
#include "RtpSession.h"

#include <aknnotewrappers.h>
#include <bitstd.h>

CSocketUdp* CSocketUdp::NewL(RtpSession *aSession)
    {
	CSocketUdp* self = new (ELeave) CSocketUdp(aSession);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
    }

CSocketUdp::CSocketUdp(RtpSession *aSession)
		: iSocketsEngineNotifier(this)
    {
		iSession = aSession;
    }

void CSocketUdp::ConstructL()
    {    
	numBytesReceived =0;
	numPacketsReceived =0;
	numBytesTransmitted =0;	
	numPacketsTransmitted=0;
	IsF = true;

	if(!iSocketsEngineNotifier)
		User::Leave(KErrArgument);
	ChangeStatus(ENotConnected);

	ConnectL();	
	iSocketsReader = CReaderUdp::NewL( *this, iSocket);
	iSocketsWriter = CWriterUdp::NewL( *this, iSocket);
	Read();
    }

CSocketUdp::~CSocketUdp()
{
	Close();

	if(iSocketsWriter)
	{
		delete iSocketsWriter;
		iSocketsWriter = NULL;
	}  
	
	if(iSocketsReader)
	{
		delete iSocketsReader;
		iSocketsReader = NULL;
	}
}

void CSocketUdp::ConnectL()
{
	if (iEngineStatus == ENotConnected)
	{
		ChangeStatus(EConnecting);

		User::LeaveIfError(iSocketSev.Connect());
		
		TInt err;
		TRAP(err, iSocket.Open(iSocketSev, KAfInet, KSockDatagram, KProtocolInetUdp));

		if(err != KErrNone)
		{
			ChangeStatus(ENotConnected);
			User::Leave(err);
		}
		iSocket.SetLocalPort(udpAddress.GetlocalPort());
		ChangeStatus(EConnected);
	}
}

void CSocketUdp::Close()
{
	if(iEngineStatus == EConnected)
	{
		if(iSocketsReader)
		{
			iSocketsReader->Cancel();
		}
		if(iSocketsWriter)
		{
			iSocketsWriter->Cancel();
		}

		if(iSocket.SubSessionHandle())
		{
			iSocket.CancelAll();
			iSocket.Close();
		}

		if (iSocketSev.Handle()) {
			iSocketSev.Close();
		}
		ChangeStatus(ENotConnected);
	}
	else
	{
		if(iSocket.SubSessionHandle())
		{
			iSocket.CancelAll();
			iSocket.Close();
		}

		if (iSocketSev.Handle()) {
			iSocketSev.Close();
		}
	}
}

// Export: Give us to send
TInt CSocketUdp::SendToL(const NetworkAddress& DestAddress,TDesC8& aData)
{
   	if (iEngineStatus != ENotConnected)
    {
		iSocketsWriter->IssueWriteL( DestAddress,aData, iEngineStatus == EConnected);
    }
	else
	{
		User::Leave(KErrNotReady);
	}
	return 0;
}

// Export: Give us to send
TInt CSocketUdp::SendToL(TDesC8& aData)
{
   	if (iEngineStatus != ENotConnected)
    {
		iSocketsWriter->IssueWriteL( udpAddress,aData, iEngineStatus == EConnected);
    }
	else
	{
		User::Leave(KErrNotReady);
	}
	return 0;
}

void CSocketUdp::Read()
{
	if ((iEngineStatus == EConnected) && (!iSocketsReader->IsActive())) 
    {
    iSocketsReader->Start();
    }
}

void CSocketUdp::SetServerIpAndPort(const TDesC& aIp, TInt aPort)
{
    iServerIp.Copy(aIp);
	iServerIp.ZeroTerminate();
    iPort = aPort;
	TBuf2Str(servIp, iServerIp);
}


char* CSocketUdp::GetAddress()
{
	return servIp;
}

int	 CSocketUdp::GetPort()
{
	return iPort;
}

void CSocketUdp::ReportError(MSocketsEngineNotifier::TErrorType aErrorType, TInt /*aErrorCode*/)
{
	if(iSocketsEngineNotifier)
	{
    switch (aErrorType)
        {
        case MSocketsEngineNotifier::EDisconnected:
            break;
        case MSocketsEngineNotifier::EGeneralReadError:
            break;
        case MSocketsEngineNotifier::EGeneralWriteError:
            break;
        default:
            break;
        }
	}
}

void CSocketUdp::ResponseReceived(const TDesC8& aBuffer, const TInetAddr& /*aRecvFrom*/)
{
	char buffer[MAX_RECV_BUFSIZE];
	
	TInt nLen = aBuffer.Length();
	
	HBufC*  temp1 = HBufC::NewL(MAX_RECV_BUFSIZE);
	temp1->Des().Copy(aBuffer);
	temp1->Des().ZeroTerminate();
	TBuf2Str(buffer,temp1->Des());

	rtpData aRtp;
	aRtp.ptrData = buffer;
	aRtp.size = nLen;
	if(iRtpQueue.TryPut( aRtp) ==0)
	{
		numBytesReceived += nLen;
		numPacketsReceived += 1;
	}
	else
	{
	}

	delete temp1;
	temp1 = NULL;
}

void CSocketUdp::ChangeStatus(TSocketsEngineState aNewStatus)
{
    iEngineStatus = aNewStatus;
}

int CSocketUdp::transmitTo ( char* buffer,
                       const int length,
                       NetworkAddress* dest )
{
    assert(buffer);
    assert(length > 0);
    assert(dest);

	TBuf8<512> aData;
	Str2TDes8(aData,buffer,length);


//	WriteFile(aData);
	SendToL(*dest,aData);

	numBytesTransmitted += length;
    numPacketsTransmitted += 1;
    return 0;
}

int CSocketUdp::RTPreceive (char* buffer,int bufSize )
{
	// test
//	if(!IsF)
//		return -1;
		
	char buf[MAX_RECV_BUFSIZE];
	memset(buf,0,MAX_RECV_BUFSIZE);
	int len =0;
	ReadFile(buf,len);

	rtpData aRtp0;
	aRtp0.ptrData = buf;
	aRtp0.size = len;
	iRtpQueue.TryPut( aRtp0);

	//

    if ((mode == sendonly) || (mode == inactive))
    {
        return -1;
    }

	rtpData aRtp;
	if(iRtpQueue.TryGet(aRtp) ==0)
	{
		memcpy(buffer,aRtp.ptrData,aRtp.size);
		bufSize = aRtp.size;
	}
	else
		return -1;
	IsF = false;
	return aRtp.size;
}


int CSocketUdp::RTCPreceive (char* buffer,int bufSize )
{
	// test
//	if(!IsF)
//		return -1;
		
	char buf[MAX_RECV_BUFSIZE];
	memset(buf,0,MAX_RECV_BUFSIZE);
	int len =0;
	ReadFile(buf,len);

	rtpData aRtp0;
	aRtp0.ptrData = buf;
	aRtp0.size = len;
	iRtpQueue.TryPut( aRtp0);

	//

    if ((mode == sendonly) || (mode == inactive))
    {
        return -1;
    }

	rtpData aRtp;
	if(iRtcpQueue.TryGet(aRtp) ==0)
	{
		memcpy(buffer,aRtp.ptrData,aRtp.size);
		bufSize = aRtp.size;
	}
	else
		return -1;
	IsF = false;
	return aRtp.size;
}

int CSocketUdp::SelectRTPStack()
{
	return iRtpQueue.IsEmpty();
}

int CSocketUdp::SelectRTCPStack()
{
	return iRtcpQueue.IsEmpty();
}