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

// Name          : SdpMediaField.cpp

// Part of       : SDP Codec

// Version       : 1.0

//

#include <s32mem.h>

#include <s32strm.h>

#include "SdpMediaField.h"

#include "SdpConnectionField.h"

#include "SdpBandwidthField.h"

#include "SdpAttributeField.h"

#include "SdpKeyField.h"

#include "sdpcodecstringconstants.h"

#include "SdpUtil.h"

#include "SDPCodec.pan"

#include "_sdpdefs.h"

#include "SdpCodecStringPool.h"

#include "SdpFmtAttributeField.h"

#include "SdpCodecTemplate.h"

#include "SdpCodecErr.h"

#include "SdpCodecParseUtil.h"

#include "SdpCodecConstants.h"

// ----------------------------------------------------------------------------

// CSdpMediaField::DecodeL

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField* 

CSdpMediaField::DecodeL(const TDesC8& aText, TBool aRecurse)

	{

	CSdpMediaField* obj = DecodeLC(aText,aRecurse);

	CleanupStack::Pop();

	return obj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::DecodeLC

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField* 

CSdpMediaField::DecodeLC(const TDesC8& aText, TBool aRecurse)

	{

	__ASSERT_ALWAYS (aText.Length() > 0, User::Leave(KErrSdpCodecMediaField));

	CSdpMediaField* obj = new(ELeave)CSdpMediaField;

	CleanupStack::PushL(obj);

	obj->ConstructL(aRecurse);

	obj->ParseL(aText);

	return obj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::NewL

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField* CSdpMediaField::NewL(RStringF aMedia,

											TUint aPort,

											RStringF aProtocol,

											const TDesC8& aFormatList)

	{

	CSdpMediaField* obj = NewLC(aMedia, aPort, aProtocol, aFormatList);

	CleanupStack::Pop();

	return obj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::NewLC

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField* CSdpMediaField::NewLC(RStringF aMedia,

											TUint aPort,

											RStringF aProtocol,

											const TDesC8& aFormatList)

	{

	CSdpMediaField* obj = new(ELeave)CSdpMediaField;

	CleanupStack::PushL(obj);

	obj->ConstructL(aMedia, aPort, aProtocol, aFormatList);

	return obj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::~CSdpMediaField

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField::~CSdpMediaField()

	{

	delete iInfo;

	delete iSdpKeyField;

	iElementArray.Reset();

	iMedia.Close();

	iProtocol.Close();

	delete iFormatList;

	delete iToken;

	if(iBandwidthFields)

		{

		iBandwidthFields->ResetAndDestroy();

		delete iBandwidthFields;

		}

	if(iAttributeFields)

		{

		iAttributeFields->ResetAndDestroy();

		delete iAttributeFields;

		}

	if(iConnectionFields)

		{

		iConnectionFields->ResetAndDestroy();

		delete iConnectionFields;

		}

	if(iFmtAttrFields)

		{

		iFmtAttrFields->ResetAndDestroy();

		delete iFmtAttrFields;

		}

	delete iSdpCodecParseUtil;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::CloneL

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpMediaField * CSdpMediaField::CloneL(TBool aRecurse) const

	{

	CSdpMediaField* obj = new(ELeave)CSdpMediaField;

	CleanupStack::PushL(obj);

	obj->ConstructL(aRecurse);

	obj->ConstructL(*this);

	CleanupStack::Pop();//obj

	return obj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::operator ==

// ----------------------------------------------------------------------------

//

EXPORT_C TBool CSdpMediaField::operator == (const CSdpMediaField& aObj) const

	{

	TBool result = ETrue;

	if(	!(iMedia==aObj.Media()) ||

		!(iPort == aObj.Port()) ||

		!(iPortCount == aObj.iPortCount) ||

		!(iProtocol == aObj.Protocol()) ||

		!(*iFormatList==(*aObj.iFormatList)) ||

		(!(*iInfo==(*aObj.iInfo)))||

		(!iSdpKeyField && aObj.Key())||

		(iSdpKeyField && !aObj.Key())||

		((iSdpKeyField && aObj.Key()) && (!(*iSdpKeyField==(*aObj.Key()))))||

		(iBandwidthFields->Count() != aObj.iBandwidthFields->Count())||

		(iAttributeFields->Count() != aObj.iAttributeFields->Count())||

		(iFmtAttrFields->Count() != aObj.iFmtAttrFields->Count())||

		(iConnectionFields->Count() != aObj.iConnectionFields->Count()))

		{

		result = EFalse;

		}

	TInt i  = 0;

	if(result)

		{

		for (i=0; i < (aObj.iConnectionFields)->Count(); i++)

			{

			if((!(*iConnectionFields)[i] && (*aObj.iConnectionFields)[i]) ||

				((*iConnectionFields)[i] && !(*aObj.iConnectionFields)[i]))

				{

				return EFalse;

				}

			if(((*iConnectionFields)[i] && (*aObj.iConnectionFields)[i]) &&

				(!(*(*iConnectionFields)[i]==(*(*aObj.iConnectionFields)[i]))))

				{	

				return EFalse;

				}

			}

		for (i=0; i < (aObj.iBandwidthFields)->Count(); i++)

			{

			if((!(*iBandwidthFields)[i] && (*aObj.iBandwidthFields)[i]) ||

				((*iBandwidthFields)[i] && !(*aObj.iBandwidthFields)[i]))

				{

				return EFalse;

				}

			if(((*iBandwidthFields)[i] && (*aObj.iBandwidthFields)[i]) &&

				(!(*(*iBandwidthFields)[i]==(*(*aObj.iBandwidthFields)[i]))))

				{	

				return EFalse;

				}

			}

		for (i=0; i < (aObj.iAttributeFields)->Count(); i++)

			{

			if((!((*iAttributeFields)[i]) && ((*aObj.iAttributeFields)[i]))||

				((*iAttributeFields)[i] && !(*aObj.iAttributeFields)[i]))

				{

				return EFalse;

				}

			if(((*iAttributeFields)[i] && (*aObj.iAttributeFields)[i]) &&

				(!(*(*iAttributeFields)[i]==(*(*aObj.iAttributeFields)[i]))))

				{

				return EFalse;

				}

			}

		for (i=0; i < (aObj.iFmtAttrFields)->Count(); i++)

			{

			if((!((*iFmtAttrFields)[i]) && ((*aObj.iFmtAttrFields)[i]))||

				((*iFmtAttrFields)[i] && !(*aObj.iFmtAttrFields)[i]))

				{

				return EFalse;

				}

			if(((*iFmtAttrFields)[i] && (*aObj.iFmtAttrFields)[i]) &&

				(!(*(*iFmtAttrFields)[i]==(*(*aObj.iFmtAttrFields)[i]))))

				{

				return EFalse;

				}

			}

		}

	return result;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Media

// ----------------------------------------------------------------------------

//

EXPORT_C RStringF CSdpMediaField::Media() const

	{

	return iMedia;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetMedia

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetMediaL(RStringF aMedia)

	{

	__ASSERT_ALWAYS(SdpUtil::IsTokenChar(aMedia.DesC()), 

					User::Leave(KErrSdpCodecMediaField));

	iMedia.Close();

	iMedia = aMedia.Copy();

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Protocol

// ----------------------------------------------------------------------------

//

EXPORT_C RStringF CSdpMediaField::Protocol() const

	{

	return iProtocol;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetProtocol

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetProtocolL(RStringF aProtocol)

	{

	__ASSERT_ALWAYS(SdpUtil::IsTokenCharWithOptionalSlash(aProtocol.DesC()),

					User::Leave(KErrSdpCodecMediaField));

    if (aProtocol == iPool.StringF( SdpCodecStringConstants::EProtocolUdp, 

                            SdpCodecStringConstants::Table ))

        {

	    __ASSERT_ALWAYS((iPort == 0 || (iPort >= 1024 && iPort <= 65535)),

					User::Leave(KErrSdpCodecMediaField));

        }

	iProtocol.Close();

	iProtocol = aProtocol.Copy();    

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Port

// ----------------------------------------------------------------------------

//

EXPORT_C TUint CSdpMediaField::Port() const

	{

	return iPort;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetPortL

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetPortL(TUint aPort)

	{

    if ( iProtocol == iPool.StringF( SdpCodecStringConstants::EProtocolUdp, 

                            SdpCodecStringConstants::Table ))

        {

	    __ASSERT_ALWAYS((aPort == 0 || (aPort >= 1024 && aPort <= 65535)),

					User::Leave(KErrSdpCodecMediaField));

        }

	iPort = aPort;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::PortCount

// ----------------------------------------------------------------------------

//

EXPORT_C TUint CSdpMediaField::PortCount() const

	{

	return iPortCount;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetPortCount

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetPortCountL(TUint aCount)

	{

	__ASSERT_ALWAYS(aCount > 0, User::Leave(KErrSdpCodecMediaField));

	iPortCount = aCount;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::FormatList

// ----------------------------------------------------------------------------

//

EXPORT_C const TDesC8& CSdpMediaField::FormatList() const

	{

	return *iFormatList;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetFormatListL

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetFormatListL(const TDesC8& aValue)

	{

	__ASSERT_ALWAYS(SdpUtil::IsTokenCharWithSpacesL(aValue), 

										User::Leave(KErrSdpCodecMediaField));

	HBufC8* tmp = aValue.AllocL();

	delete iFormatList;

	iFormatList = tmp;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::CSdpMediaField

// ----------------------------------------------------------------------------

//

CSdpMediaField::CSdpMediaField()

	{

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::ConstructL

// ----------------------------------------------------------------------------

//

void CSdpMediaField::ConstructL()

	{

	iPool = SdpCodecStringPool::StringPoolL();

	iInfo = KNullDesC8().AllocL();

	iFormatList = KNullDesC8().AllocL();

	iToken = KNullDesC8().AllocL();

	iBandwidthFields = new(ELeave)RPointerArray<CSdpBandwidthField>;

	iConnectionFields = new(ELeave)RPointerArray<CSdpConnectionField>;

	iAttributeFields = new(ELeave)RPointerArray<CSdpAttributeField>;

	iFmtAttrFields = new(ELeave)RPointerArray<CSdpFmtAttributeField>;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::ConstructL

// ----------------------------------------------------------------------------

//

void CSdpMediaField::ConstructL(TBool aRecurse)

	{

	ConstructL();

	iRecurse = aRecurse;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::ConstructL

// ----------------------------------------------------------------------------

//

void 

CSdpMediaField::ConstructL(RStringF aMedia, TUint aPort, RStringF aProtocol,

						const TDesC8& aFormatList)

	{

	__ASSERT_ALWAYS(SdpUtil::IsTokenChar(aMedia.DesC()) &&

					(aPort== 0 || (aPort >= 1024 && aPort <= 65535)) &&

					SdpUtil::IsTokenCharWithOptionalSlash(aProtocol.DesC()) &&

					SdpUtil::IsTokenCharWithSpacesL(aFormatList), 

					User::Leave(KErrArgument));

	ConstructL();

	iMedia = aMedia.Copy();

	iProtocol = aProtocol.Copy(); 

	SetPortL(aPort);

	delete iFormatList;

	iFormatList = 0;

	iFormatList = aFormatList.AllocL();	

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::ConstructL

// ----------------------------------------------------------------------------

//

void CSdpMediaField::ConstructL(const CSdpMediaField& aSdpMediaField)

	{

	iMedia = aSdpMediaField.Media().Copy();

	iProtocol = aSdpMediaField.Protocol().Copy();

    SetPortL(aSdpMediaField.Port());

	iPortCount = aSdpMediaField.PortCount();

	HBufC8* tmp = aSdpMediaField.FormatList().AllocL();

	delete iFormatList;

	iFormatList = 0;

	iFormatList = tmp;

	if(iRecurse)

		{

		tmp = aSdpMediaField.Info().AllocL();

		delete iInfo;

		iInfo = tmp;

		SdpCodecTemplate<CSdpConnectionField>::CloneArrayL(*iConnectionFields,

			*aSdpMediaField.iConnectionFields);

		SdpCodecTemplate<CSdpBandwidthField>::CloneArrayL(*iBandwidthFields,

			*aSdpMediaField.iBandwidthFields);

		if(aSdpMediaField.Key())

			{

			iSdpKeyField = aSdpMediaField.Key()->CloneL();

			}

		SdpCodecTemplate<CSdpAttributeField>::CloneArrayL(*iAttributeFields,

			*aSdpMediaField.iAttributeFields);

		SdpCodecTemplate<CSdpFmtAttributeField>::CloneArrayL(*iFmtAttrFields,

			*aSdpMediaField.iFmtAttrFields);		

		}

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Info

// ----------------------------------------------------------------------------

//

EXPORT_C const TDesC8& CSdpMediaField::Info() const

	{

	return *iInfo;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetInfoL

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetInfoL(const TDesC8& aValue)

	{

	__ASSERT_ALWAYS (aValue.Compare(KNullDesC8) == 0||

					SdpUtil::IsByteString(aValue),

					User::Leave(KErrSdpCodecMediaInfoField));

	HBufC8* tmp = aValue.AllocL();

	tmp->Des().Trim();

	delete iInfo;

	iInfo = tmp;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Key

// ----------------------------------------------------------------------------

//

EXPORT_C CSdpKeyField* CSdpMediaField::Key()

	{

	return iSdpKeyField;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::Key

// ----------------------------------------------------------------------------

//

EXPORT_C const CSdpKeyField* CSdpMediaField::Key() const

	{

	return iSdpKeyField;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::SetKey

// ----------------------------------------------------------------------------

//

EXPORT_C void CSdpMediaField::SetKey(CSdpKeyField* aObj)

	{

	delete iSdpKeyField;

	iSdpKeyField = aObj;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::ConnectionFields

// ----------------------------------------------------------------------------

//

EXPORT_C RPointerArray<CSdpConnectionField>& CSdpMediaField::ConnectionFields()

	{

	return *iConnectionFields;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::BandwidthFields

// ----------------------------------------------------------------------------

//

EXPORT_C RPointerArray<CSdpBandwidthField>& CSdpMediaField::BandwidthFields()

	{

	return *iBandwidthFields;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::AttributeFields

// ----------------------------------------------------------------------------

//

EXPORT_C RPointerArray<CSdpAttributeField>& CSdpMediaField::AttributeFields()

	{

	return *iAttributeFields;

	}

// ----------------------------------------------------------------------------

// CSdpMediaField::FormatAttributeFields()

// ----------------------------------------------------------------------------

//

EXPORT_C RPointerArray<CSdpFmtAttributeField>& 

CSdpMediaField::FormatAttributeFields()

	{

	return *iFmtAttrFields;

	}

// ----------------------------------------------------------------------------