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

//

#include <es_sock.h>

#include <btsdp.h>

#include "attrvalueencoded.h"

#include "sdpconsts.h"

#include "SDPServiceRecord.h"

#include "sdputil.h"

// ******************* CSdpServRecord ********************************

EXPORT_C CSdpServRecord *CSdpServRecord::NewL()

	{

	CSdpServRecord *self=new (ELeave) CSdpServRecord(KNullUid);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CSdpServRecord *CSdpServRecord::NewServerSideL(const TUid& aUid)

	{

	CSdpServRecord *self=new (ELeave) CSdpServRecord(aUid);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CSdpServRecord::CSdpServRecord(const TUid& aClientUid)

	: iAttributes(CSdpAttr::LinkOffset()), iClientUid(aClientUid)

	{

	}

void CSdpServRecord::ConstructL()

	{

	TPckg<TUint> intBuf(0);

	iRecordState = CSdpAttrValueUint::NewUintL(intBuf);

	// Create the buffer the correct size for storing a Uint

	TInt encodedSize = TElementEncoder::EncodedSize(iRecordState->Type(), iRecordState->DataSize());

	iEncodeBuf.CreateL(encodedSize);

	TElementEncoder encoder(iEncodeBuf);

	iEncoderVisitor = CAttrEncoderVisitor::NewL(encoder);

	}

CSdpServRecord::~CSdpServRecord()

	{

	// Delete all attributes on the attribute list

	iAttributes.ResetAndDestroy();

	// Remove this servRecord from any Q it might be on

	iLink.Deque();

	delete iEncoderVisitor;

	delete iRecordState;

	iEncodeBuf.Close();

	}

// handle may be encoded

EXPORT_C TSdpServRecordHandle CSdpServRecord::Handle() const

	{

	__ASSERT_ALWAYS(!iAttributes.IsEmpty(), DbPanic(ESdpDbRecordBadHandle));

	CSdpAttr *first = iAttributes.First();

	__ASSERT_ALWAYS(first->AttributeID() == 0, DbPanic(ESdpDbRecordBadHandle));

//	__ASSERT_ALWAYS(first->Value().Type() == ETypeUint, DbPanic(ESdpDbRecordBadHandle));

// needs to test for an encoded value, can we decode ?

	TSdpServRecordHandle retVal;

	TUint8* ptr = (TUint8*)first->Value().Des().Ptr();

	switch (first->Value().Type())

		{

		case ETypeUint:

			retVal = first->Value().Uint();

			break;

		case ETypeEncoded:

			{

			const TUint8 KTUint32Header = (ETypeUint << KSdpElemHdrTypeShift) | ESizeFourBytes;

			if (*ptr++ != KTUint32Header) DbPanic(ESdpAttrValueBadSize);

			retVal = BigEndian::Get32(ptr);

			}

			break;

		default:

			DbPanic(ESdpDbRecordBadHandle);

			return 0;	// no warnings

		}

	return retVal;

	}

EXPORT_C TUid CSdpServRecord::ClientUid() const

	{

	return iClientUid;

	}

/**

@see RecordStateChange

*/

EXPORT_C void CSdpServRecord::AddAttribute(CSdpAttr* aAttr)

/**

	This function adds an attribute to this record

**/

	{

	iAttributes.AddInOrder(*aAttr);

	}

/**

If an attribute for this record is updated or deleted this method

shall be called.  It will update the state attribute, which may

be used by remote devices to aid caching.

@internalTechnology

@released

*/

EXPORT_C void CSdpServRecord::RecordStateChange()

	{

	TDblQueIter<CSdpAttr> attrIter(iAttributes);

	CSdpAttr* attr = attrIter++;

	while(attr)

		{

		if(attr->AttributeID() == KSdpAttrIdServiceRecordState)

			{

			TUint state = iRecordState->Uint();

			TPckg<TUint> stateBuf(0);

			SdpUtil::PutUint(&stateBuf[0], ++state, sizeof(TUint));

			iRecordState->SetUintValue(stateBuf);

			// This encodes iRecordState into the buffer provided at construction

			iEncodeBuf.SetLength(0);

			TRAPD(err, iEncoderVisitor->EncodeAttributeL(*iRecordState));

			// Attribute encoding can only fail if the attribute is of an unknown type 

			// or the supplied buffer is too small.  We have set the length of the

			// buffer to the correct length on creation so that will not fail.

			// We know iRecordState is a CSdpAttrValueUint so cannot fail.

			__ASSERT_ALWAYS(!err, DbPanic(ESdpDbAttributeEncodingFailed));

			__ASSERT_ALWAYS(attr->Value().Type() == ETypeEncoded, DbPanic(ESdpDbStoredAttrValNotEncoded));

			reinterpret_cast<CSdpAttrValueEncoded&>(attr->Value()).SetEncodedValue(iEncodeBuf);

			break;

			}

		attr = attrIter++;

		}

	}

MSdpElementBuilder *CSdpServRecord::BuildUintL(const TDesC8& aUint)

/**

	This function builds a new attribute

**/

	{

	TUint16 id=0;

	TInt len = aUint.Length();

	if (len==1)

		id = aUint[0];	// Strictly this is an error

	else if (len==2)

		id = BigEndian::Get16(&aUint[0]);

	else

		User::Leave(KErrSdpBadAttributeId);

	CSdpAttr *attr=CSdpAttr::NewL(id,this);

	iAttributes.AddInOrder(*attr);

	return attr;

	}

EXPORT_C CRecordAttr::CRecordAttr()

: iValue(0)

	{

	}

EXPORT_C CRecordAttr::~CRecordAttr()

	{

	}

MSdpElementBuilder* CRecordAttr::BuildUintL(const TDesC8& aUint)

	{

	iValue = SdpUtil::GetUint(aUint);

	return this;

	}