// 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 <e32math.h>
#include <utf.h>
#include <es_sock.h>
#include <bt_sock.h>
#include <btsdp.h>
#include "ipcinternals.h"
#include "sdpkey.h"
#include "sdputil.h"
#include "SDPDatabase.h"
#include "DataEncoder.h"
#include "SDPAttribute.h"
#include "EncoderVisitor.h"
#include "ExtractorVisitor.h"
#include "agtypes.h"
#include "agutil.h"
#include "ProtocolWrapper.h"



/************************************************************************/
//
//   SDP agent client API 
//	(only exists as an exported API for porting purposes)
//
/************************************************************************/


RSdpAgent::RSdpAgent()
:iRequestBuf(0), iResultSize(0)
/**
	Constructer:
	Set the HBufC pointer iRequestBuf to NULL (This is an 'R' class).
	Set the TPckg iResultSize to package nothing. 
**/
	{
	}

TInt RSdpAgent::Open(RSdpSession& aSession)
/**
	Open a NetDatabase session on ESock using SDP over Bluetooth.
**/
	{
	return iNetDb.Open(aSession,KBTAddrFamily,KSDP);
	}

void RSdpAgent::Close()
/**
	Free iRequestBuf.
	Close RNetDatabase.
**/
	{
	delete iRequestBuf;
	iRequestBuf = 0;
	iNetDb.Close();
	}

TBool RSdpAgent::IsOpen()
	{
	return iNetDb.SubSessionHandle()==0?EFalse:ETrue;
	}
	
void RSdpAgent::Connect(TBTDevAddr aRemoteAddr, TRequestStatus& aStatus)
/**
	Ask to connect to remote device.
**/
	{
	TSDPConnectQuery connQ;

	connQ.iQueryType = KSDPConnectQuery;
	connQ.iAddr = aRemoteAddr;

	iResultSize.Set(0,0,0);
	iConnectBuf = connQ;
	iNetDb.Query(iConnectBuf, iResultSize, aStatus);
	}

void RSdpAgent::SdpSearchRequestL(TInt& aResultSize, 
								  CSdpAttrValueDES& aUUIDList,
								  TUint16 aMaxRecCount, 
								  const TDesC8& aContState,
								  TRequestStatus& aStatus)
/**
	Ask for a service search using a list attribute value (CSdpAttrValueDES).
	THIS FUNCTION SHOULD NEVER BE EXPORTED AS IS...a general
	list attribute value is open to misuse.
	The reply to this function is to send the SIZE of the response back
	in the aResultSize parameter. Once this is done the user of this class
	can set up a buffer big enough to collect the response from server side.
**/
	{
	TSDPEncodedKeyBuf key;
	if(aContState.Length() > KSdpContinuationStateMaxLength)
		{
		User::Leave(KErrArgument);
		}
	key().iQueryType = KSDPEncodedQuery | KSDPBufferResult; 
	key().iPduId = EServiceSearchRequest;

	TUint size = TElementEncoder::EncodedSize(ETypeDES, aUUIDList.DataSize());
	delete iRequestBuf;
	iRequestBuf = 0;
	iRequestBuf = HBufC8::NewL(sizeof(key)+size+2+1+KSdpContinuationStateMaxLength);
	TPtr8 ptr = iRequestBuf->Des();

	// Build the request PDU
	ptr.Copy(key);
	TElementEncoder ee(ptr);
	CAttrEncoderVisitor::EncodeAttributeL(ee, aUUIDList);
	TBuf8<2> sbuf;
	sbuf.SetMax();
	BigEndian::Put16(&sbuf[0], aMaxRecCount);	// Maximum Service record count
	ptr.Append(sbuf);
	ptr.Append((TUint8)aContState.Length());
	ptr.Append(aContState);

	iResultSize.Set(TPckg<TInt>(aResultSize));
		iResultSize.SetMax();
	iNetDb.Query(*iRequestBuf, iResultSize, aStatus);
	}


void RSdpAgent::SdpSearchRequestL(TInt& aResultSize, 
								  CSdpSearchPattern& aUUIDFilter,
								  TUint16 aMaxRecCount, 
								  const TDesC8& aContState,
								  TRequestStatus& aStatus)
/**
	Ask for a service search using a UUID search pattern (CSdpSearchPattern).
	THIS FUNCTION SHOULD MAY BE EXPORTED (UNLIKE THE OTHER "SdpSearchRequestL")
	AT SOME FUTURE DATE.
	The reply to this function is to send the SIZE of the response back
	in the aResultSize parameter. Once this is done the user of this class
	can set up a buffer big enough to collect the response from server side.
**/
	{
	CSdpAttrValueDES* avEquiv = CSdpAttrValueDES::NewDESL(0);
	CleanupStack::PushL(avEquiv);
	MSdpElementBuilder* bldr = avEquiv->StartListL();
	for (TInt i = 0; i < aUUIDFilter.Count(); ++i)
		{
		TUUID uuid = aUUIDFilter.At(i);
		bldr = bldr->BuildUUIDL(uuid);
		}
	bldr->EndListL();
	CSdpAttrValueDES* avEquivT = CSdpAttrValueDES::NewDESL(0);
	CleanupStack::PushL(avEquivT);
	avEquivT->StartListL()
		->BuildUUIDL(0x1100)
		->BuildUUIDL(0x1101)
		->BuildUUIDL(0x1102)
	->EndListL();

	SdpSearchRequestL(aResultSize, *avEquiv, aMaxRecCount, aContState, aStatus);
	CleanupStack::PopAndDestroy(); //avEquivT
	CleanupStack::PopAndDestroy(); //avEquiv
	}


void RSdpAgent::SdpAttributeRequestL(TInt& aResultSize, 
									 TSdpServRecordHandle aHandle, 
								     TUint16 aMaxAttrByteCount,
									 CSdpAttrIdMatchList& aMatchList,
									 const TDesC8& aContState,
									 TRequestStatus& aStatus)
/**
	Ask for an attribute request using an ID match list (CSdpAttrIdMatchList).
	The reply to this function is to send the SIZE of the response back
	in the aResultSize parameter. Once this is done the user of this class
	can set up a buffer big enough to collect the response from server side.
**/
	{
	if(aContState.Length() > KSdpContinuationStateMaxLength)
		{
		User::Leave(KErrArgument);
		}

	__ASSERT_ALWAYS(aMaxAttrByteCount >= 7, AgPanic(ESdpAgentBadResultLength));
	
	TSDPEncodedKeyBuf key;
	key().iQueryType = KSDPEncodedQuery | KSDPBufferResult;
	key().iPduId = EServiceAttributeRequest;

	TUint size = TElementEncoder::EncodedSize(ETypeDES, aMatchList.Count() * 5);
	delete iRequestBuf;
	iRequestBuf = 0;
	iRequestBuf = HBufC8::NewL(size + 4 + 2 + KSdpContinuationStateMaxLength + 1);
	TPtr8 ptr = iRequestBuf->Des();

	TElementEncoder ee(ptr);
	
	// Build the request PDU
	ptr.Copy(key);
	TBuf8<6> sbuf(6);
	BigEndian::Put32(&sbuf[0], aHandle);	// Record handle
	BigEndian::Put16(&sbuf[4], TUint16(aMaxAttrByteCount));	// Max byte count
	ptr.Append(sbuf);
	aMatchList.EncodeL(ee);	// AttrID list
	ptr.Append((TUint8)aContState.Length());
	ptr.Append(aContState);

	iResultSize.Set(TPckg<TInt>(aResultSize));
	iResultSize.SetMax();
	iNetDb.Query(*iRequestBuf, iResultSize, aStatus);
	}

TInt RSdpAgent::RetrieveResult(TDes8& aResult)
/**
	On completion of a service search or attribute request RSdpAgent
	is sent the size of the response by the server. To obtain the actual
	result (buffered in the server) a user needs to call this function.
	NB. This is a synchronous request.
**/
	{
	TPckgBuf<TUint> key(KSDPRetrieveResultQuery);
	return iNetDb.Query(key, aResult);
	}

void RSdpAgent::Cancel()
/**
	Pass "Cancel" call up to RNetDatabase.
**/
	{
	iNetDb.Cancel();
	}