// 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          : SdpDocument.cpp

// Part of       : SDP Codec

// Version       : 1.0

//

#include <s32strm.h>

#include <e32std.h>

#include "SdpDocument.h"

#include "SdpTimeField.h"

#include "SdpBandwidthField.h"

#include "SdpAttributeField.h"

#include "SdpMediaField.h"

#include "SdpConnectionField.h"

#include "SdpKeyField.h"

#include "SdpOriginField.h"

#include "SdpRepeatField.h"

#include "sdpcodecstringconstants.h"

#include "SdpCodecErr.h"

#include "SdpCodecConstants.h"

#include "uri8.h"

#include "uriutilscommon.h"

#include "badesca.h"

#include "_sdpdefs.h"

#include "SdpCodecStringPool.h"

#include "SdpUtil.h"

#include "SdpCodecTemplate.h"

#include "SdpCodecParseUtil.h"

_LIT8(KCRLF, "\r\n");

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

// CSdpDocument::DecodeL

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

//

EXPORT_C CSdpDocument* 

CSdpDocument::DecodeL(const TDesC8& aText)

	{

	CSdpDocument* sdpDocument = CSdpDocument::DecodeLC(aText);

	CleanupStack::Pop();

	return sdpDocument;

	}

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

// CSdpDocument::DecodeLC

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

//

EXPORT_C CSdpDocument* 

CSdpDocument::DecodeLC(const TDesC8& aText)

	{

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

	CSdpDocument* sdpDocument = new(ELeave)CSdpDocument;

	CleanupStack::PushL(sdpDocument);

	sdpDocument->ConstructL();

	sdpDocument->ParseL(aText);

	return sdpDocument;

	}

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

// CSdpDocument::NewL

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

//

EXPORT_C CSdpDocument* CSdpDocument::NewL()

	{

	CSdpDocument* self = CSdpDocument::NewLC();

	CleanupStack::Pop();

	return self;

	}

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

// CSdpDocument::NewLC

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

//

EXPORT_C CSdpDocument* CSdpDocument::NewLC()

	{

	CSdpDocument* self = new(ELeave)CSdpDocument;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// CSdpDocument::~CSdpDocument

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

//

EXPORT_C CSdpDocument::~CSdpDocument()

	{

	delete iInfo;

	delete iSessionName;

	delete iZoneAdjustments;

	delete iSdpKeyField;

	delete iSdpOriginField;

	delete iSdpConnectionField;

	if(iTimeFields)

		{

		iTimeFields->ResetAndDestroy();

		delete iTimeFields;

		}

	if(iBandwidthFields)

		{

		iBandwidthFields->ResetAndDestroy();

		delete iBandwidthFields;

		}

	if(iAttributeFields)

		{

		iAttributeFields->ResetAndDestroy();

		delete iAttributeFields;

		}

	if(iMediaFields)

		{

		iMediaFields->ResetAndDestroy();

		delete iMediaFields;

		}

	delete iUri;

	if(iEmailFields)

		{

		iEmailFields->Reset();

		delete iEmailFields;

		}

	if(iPhoneFields)

		{

		iPhoneFields->Reset();

		delete iPhoneFields;

		}

	delete iToken;

	delete iSdpCodecParseUtil;

	}

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

// CSdpDocument::ExternalizeL

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

//

EXPORT_C void CSdpDocument::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteUint32L (iSdpVersion);	

	SdpCodecTemplate<CSdpOriginField>::ExternalizeL(OriginField(), aStream);

	aStream.WriteUint32L (iSessionName->Length());

	if (iSessionName->Length() > 0)

		{

		aStream.WriteL (*iSessionName);

		}

	aStream.WriteUint32L (iInfo->Length());

	if (iInfo->Length() > 0)

		{

		aStream.WriteL (*iInfo);

		}

	if(Uri())

		{

		aStream.WriteUint8L (1);

		aStream.WriteUint32L ((iUri->Uri()).UriDes().Length());

		aStream.WriteL((iUri->Uri()).UriDes());

		}

	else

		{

		aStream.WriteUint8L (0);

		}

	ExternalizeDesCArrayL(*iEmailFields, aStream);

	ExternalizeDesCArrayL(*iPhoneFields, aStream);

	SdpCodecTemplate<CSdpConnectionField>::ExternalizeL(iSdpConnectionField,

														aStream);

	SdpCodecTemplate<CSdpBandwidthField>::ExternalizeArrayL(*iBandwidthFields,

															aStream);

	SdpCodecTemplate<CSdpTimeField>::ExternalizeArrayL(*iTimeFields, aStream);

	aStream.WriteUint32L (iZoneAdjustments->Length());

	if (iZoneAdjustments->Length() > 0)

		{

		aStream.WriteL (*iZoneAdjustments);

		}

	SdpCodecTemplate<CSdpKeyField>::ExternalizeL(Key(), aStream);

	SdpCodecTemplate<CSdpAttributeField>::ExternalizeArrayL(*iAttributeFields,

															aStream);

	SdpCodecTemplate<CSdpMediaField>::ExternalizeArrayL(*iMediaFields, 

															aStream);

	}

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

// CSdpDocument::InternalizeL

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

//

EXPORT_C CSdpDocument* 

CSdpDocument::InternalizeL(RReadStream& aStream)

	{

	CSdpDocument* self = new(ELeave)CSdpDocument;

	CleanupStack::PushL(self);

	self->ConstructL();

	self->DoInternalizeL (aStream);

	CleanupStack::Pop();

	return self;

	}

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

// CSdpDocument::DoInternalizeL

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

//

void CSdpDocument::DoInternalizeL(RReadStream& aStream)

	{

	if(iTimeFields)

		{

		iTimeFields->ResetAndDestroy();

		}

	iSdpVersion = aStream.ReadUint32L();

	if(aStream.ReadUint8L())

		{

		SetOriginField(CSdpOriginField::InternalizeL(aStream));

		}

	SetSessionNameL(GetTokenFromStreamL(aStream));

	SetInfoL(GetTokenFromStreamL(aStream));

	if(aStream.ReadUint8L())

		{

		TUriParser8 parser;

		User::LeaveIfError(parser.Parse(GetTokenFromStreamL(aStream)));

		SetUri(CUri8::NewL(parser));

		}

	TInt i = 0;

	TInt count = aStream.ReadUint32L();

	for (i = 0;i < count;i++)

		{

		TPtrC8 temp(GetTokenFromStreamL(aStream));

		if(temp.Compare(KNullDesC8) != 0)

			{

			iEmailFields->AppendL(temp);

			}

		}

	count = aStream.ReadUint32L();

	for (i = 0;i < count;i++)

		{

		TPtrC8 temp(GetTokenFromStreamL(aStream));

		if(temp.Compare(KNullDesC8) != 0)

			{

			iPhoneFields->AppendL(temp);

			}

		}

	if(aStream.ReadUint8L())

		{

		SetConnectionField(CSdpConnectionField::InternalizeL(aStream));

		}

	SdpCodecTemplate<CSdpBandwidthField>::InternalizeArrayL(

												*iBandwidthFields, aStream);

	SdpCodecTemplate<CSdpTimeField>::InternalizeArrayL(*iTimeFields,

														aStream);

	SetZoneAdjustmentsL(GetTokenFromStreamL(aStream));

	if(aStream.ReadUint8L())

		{

		SetKey(CSdpKeyField::InternalizeL(aStream));

		}

	SdpCodecTemplate<CSdpAttributeField>::InternalizeArrayL(

												*iAttributeFields, aStream);

	SdpCodecTemplate<CSdpMediaField>::InternalizeArrayL(*iMediaFields,

															aStream);

	}

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

// CSdpDocument::EncodeL

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

//

EXPORT_C void CSdpDocument::EncodeL(RWriteStream& aStream) const

	{

	RStringF headername = iPool.StringF( SdpCodecStringConstants::EVersion, 

                                              SdpCodecStringConstants::Table );

    aStream.WriteL(headername.DesC());

	TBuf8<80> text;

	text.Format(_L8("%u"), iSdpVersion);

	aStream.WriteL(text);

	aStream.WriteL(KCRLF);	

	SdpCodecTemplate<CSdpOriginField>::EncodeL(OriginField(), aStream);

	SdpUtil::EncodeBufferL(*iSessionName, SdpCodecStringConstants::ESession,

																	aStream);

	SdpUtil::EncodeBufferL(*iInfo, SdpCodecStringConstants::EInfo, aStream);

	if(Uri())

		{

		SdpUtil::EncodeBufferL(((iUri->Uri()).UriDes()), 

					SdpCodecStringConstants::EUri, aStream);

		}

	EncodeDesCArrayL(*iEmailFields, SdpCodecStringConstants::EEmail, aStream);

	EncodeDesCArrayL(*iPhoneFields, SdpCodecStringConstants::EPhone, aStream);

	SdpCodecTemplate<CSdpConnectionField>::EncodeL(iSdpConnectionField,

														aStream);

	SdpCodecTemplate<CSdpBandwidthField>::EncodeArrayL(*iBandwidthFields,

														aStream);

	SdpCodecTemplate<CSdpTimeField>::EncodeArrayL(*iTimeFields, aStream);

	SdpUtil::EncodeBufferL(*iZoneAdjustments,

							SdpCodecStringConstants::EZone, aStream);

	SdpCodecTemplate<CSdpKeyField>::EncodeL(Key(), aStream);

	SdpCodecTemplate<CSdpAttributeField>::EncodeArrayL(*iAttributeFields, 

														aStream);

	SdpCodecTemplate<CSdpMediaField>::EncodeArrayL(*iMediaFields, aStream);

	}

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

// CSdpDocument::CloneL

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

//

EXPORT_C CSdpDocument* CSdpDocument::CloneL() const

	{

	CSdpDocument* sdpdocument = new(ELeave)CSdpDocument;

	CleanupStack::PushL(sdpdocument);

	sdpdocument->ConstructL(*this);

	CleanupStack::Pop();//sdpdocument

	return sdpdocument;

	}

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

// CSdpDocument::IsValid

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

//

EXPORT_C TBool CSdpDocument::IsValid() const

	{

	if (iTimeFields->Count() == 0 || !OriginField() ||

        !SessionName().Length()||

		(!iMediaFields->Count() && !ConnectionField()))

		{

		return EFalse;

		}

    TInt j;

	for (j=0; j < iMediaFields->Count(); j++)

		{

		if(!(*iMediaFields)[j]->IsValid() || 

			(!ConnectionField() && (!(*iMediaFields)[j]->IsContactPresent())))

			{

			return EFalse;

			}

		}

    for (j=0; j < iTimeFields->Count(); j++)

		{

        if ( !(*iTimeFields)[j]->IsValid())

            {

		    return EFalse;

            }

		}

	return ETrue;

	}

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

// CSdpDocument::SdpVersion

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

//

EXPORT_C TUint CSdpDocument::SdpVersion() const

	{

	return iSdpVersion;

	}

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

// CSdpDocument::OriginField

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

//

EXPORT_C CSdpOriginField* CSdpDocument::OriginField()

	{

	return iSdpOriginField;

	}

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

// CSdpDocument::OriginField

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

//

EXPORT_C const CSdpOriginField* CSdpDocument::OriginField() const

	{

	return iSdpOriginField;

	}

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

// CSdpDocument::SetOriginField

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

//

EXPORT_C void CSdpDocument::SetOriginField(CSdpOriginField* aObj)

	{

	delete iSdpOriginField;

	iSdpOriginField = aObj;

	}

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

// CSdpDocument::SessionName

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

//

EXPORT_C const TDesC8& CSdpDocument::SessionName() const

	{

	return *iSessionName;

	}

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

// CSdpDocument::SetSessionNameL

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

//

EXPORT_C void CSdpDocument::SetSessionNameL(const TDesC8& aValue)

	{

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

					aValue.Compare(_L8(" ")) == 0||

					SdpUtil::IsByteString(aValue),

	                 User::Leave(KErrSdpCodecSessionField));

	HBufC8* tmp = aValue.AllocL();

	delete iSessionName;

	iSessionName = tmp;

	}

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

// CSdpDocument::Info

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

//

EXPORT_C const TDesC8& CSdpDocument::Info() const

	{

	return *iInfo;

	}

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

// CSdpDocument::SetInfoL

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

//

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

	{

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

					SdpUtil::IsByteString(aValue),

	                 User::Leave(KErrSdpCodecInfoField));

	HBufC8* tmp = aValue.AllocL();

	tmp->Des().Trim();

	delete iInfo;

	iInfo = tmp;

	}

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

// CSdpDocument::Uri

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

//

EXPORT_C CUri8* CSdpDocument::Uri() 

	{

	return iUri;

	}

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

// CSdpDocument::Uri

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

//

EXPORT_C const CUri8* CSdpDocument::Uri() const

	{

	return iUri;

	}

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

// CSdpDocument::SetUriL

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

//

EXPORT_C void CSdpDocument::SetUri(CUri8* aValue)

	{

	delete iUri;

	iUri = aValue;

	}

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

// CSdpDocument::EmailFields

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

//

EXPORT_C CDesC8Array& CSdpDocument::EmailFields()

	{

	return *iEmailFields;

	}

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

// CSdpDocument::PhoneFields

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

//

EXPORT_C CDesC8Array& CSdpDocument::PhoneFields()

	{

	return *iPhoneFields;

	}

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

// CSdpDocument::ConnectionField

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

//

EXPORT_C CSdpConnectionField* CSdpDocument::ConnectionField()

	{

	return iSdpConnectionField;

	}

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

// CSdpDocument::ConnectionField

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

//

EXPORT_C const CSdpConnectionField* CSdpDocument::ConnectionField() const

	{

	return iSdpConnectionField;

	}

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

// CSdpDocument::SetConnectionField

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

//

EXPORT_C void CSdpDocument::SetConnectionField(CSdpConnectionField* aObj)

	{

	delete iSdpConnectionField;

	iSdpConnectionField = aObj;

	}

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

// CSdpDocument::BandwidthFields

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

//

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

	{

	return *iBandwidthFields;

	}

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

// CSdpDocument::TimeFields

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

//

EXPORT_C RPointerArray<CSdpTimeField>& CSdpDocument::TimeFields()

	{

	return *iTimeFields;

	}

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

// CSdpDocument::ZoneAdjustments

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