// 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:

//

/**

 @file

 @publishedAll

 @released

*/

#ifndef BTSDP_H

#define BTSDP_H

#include <e32base.h>

#include <bttypes.h>

/** The UID of the SDP Server. 

@see TBTServiceSecurity */

static const TUid KUidServiceSDP			= {0x100095FA};

/** Attribute ID. */

typedef TUint16 TSdpAttributeID;

// Universal Attributes

/** Service Record Handle. */

static const TSdpAttributeID KSdpAttrIdServiceRecordHandle = 0x0000;

/** Service ClassID List. */

static const TSdpAttributeID KSdpAttrIdServiceClassIDList = 0x0001;

/** Service Record State. */

static const TSdpAttributeID KSdpAttrIdServiceRecordState = 0x0002;

/** ServiceID. */

static const TSdpAttributeID KSdpAttrIdServiceID = 0x0003;

/** Protocol Descriptor List. */

static const TSdpAttributeID KSdpAttrIdProtocolDescriptorList = 0x0004;

/** Browse Group List. */

static const TSdpAttributeID KSdpAttrIdBrowseGroupList = 0x0005;

/** Language Base Attribute ID List. */

static const TSdpAttributeID KSdpAttrIdLanguageBaseAttributeIDList = 0x0006;

/** Service Info Time To Live. */

static const TSdpAttributeID KSdpAttrIdServiceInfoTimeToLive = 0x0007;

/** Service Availability. */

static const TSdpAttributeID KSdpAttrIdServiceAvailability = 0x0008;

/** Bluetooth Profile Descriptor List. */

static const TSdpAttributeID KSdpAttrIdBluetoothProfileDescriptorList = 0x0009;

/** Documentation URL. */

static const TSdpAttributeID KSdpAttrIdDocumentationURL = 0x000A;

/** Client Executable URL. */

static const TSdpAttributeID KSdpAttrIdClientExecutableURL = 0x000B;

/** Icon URL. */

static const TSdpAttributeID KSdpAttrIdIconURL = 0x000C;

/** Additional protocol descriptor list. */

static const TSdpAttributeID KSdpAttrIdAdditionalProtocolDescriptorList = 0x000D;

/** PAN Profile Security enforcement */

static const TSdpAttributeID KSdpAttrIdSecurityDescription = 0x030a;

/** PAN Profile, NAP access type */

static const TSdpAttributeID KSdpAttrIdNetAccessType = 0x030b;

/** PAN Profile, NAP maximum throughput of uplink network (octets/second) */

static const TSdpAttributeID KSdpAttrIdMaxNetAccessRate = 0x030c;

/** PAN Profile, NAP IPv4 Subnet */

static const TSdpAttributeID KSdpAttrIdIPv4Subnet = 0x030d;

/** PAN Profile, NAP IPv6 Subnet */

static const TSdpAttributeID KSdpAttrIdIPv6Subnet = 0x030e;

/** SupportedCapabilities */

static const TSdpAttributeID KSdpAttrIdSupportedCapabilities = 0x0310;

/** SupportedFeatures */

static const TSdpAttributeID KSdpAttrIdSupportedFeatures = 0x0311;

/** SupportedFunctions */

static const TSdpAttributeID KSdpAttrIdSupportedFunctions = 0x0312;

// Language specific attributes

/** Primary Language. */

static const TSdpAttributeID KSdpAttrIdBasePrimaryLanguage = 0x0100;

static const TSdpAttributeID KSdpAttrIdCharacterEncodingUTF8 = 0x006a;

/** Service Name.

This is an offset that should be added to the attribute ID base (contained 

in the LanguageBaseAttributeIDList attribute). */

static const TInt KSdpAttrIdOffsetServiceName = 0x0000; // + Language offset

/** Service Description.

This is an offset that should be added to the attribute ID base (contained 

in the LanguageBaseAttributeIDList attribute). */

static const TInt KSdpAttrIdOffsetServiceDescription = 0x0001; // + Language offset

/** Provider Name.

This is an offset that should be added to the attribute ID base (contained 

in the LanguageBaseAttributeIDList attribute). */

static const TInt KSdpAttrIdOffsetProviderName = 0x0002; // + Language offset

// SDP server specific attributes

/** Version Number List. */

static const TSdpAttributeID KSdpAttrIdSdpServerVersionNumberList = 0x0200;

/** Service Database State. */

static const TSdpAttributeID KSdpAttrIdSdpServerServiceDatabaseState = 0x0201;

/** GroupID. */

static const TSdpAttributeID KSdpAttrIdSdpServerGroupID = 0x0200;

// Protocol UUIDs (add to these as necessary)

static const TInt KL2CAPUUID = 0x0100;

static const TInt KBnepUUID = 0x000f;

static const TInt KAvctpUUID = 0x0017;

static const TInt KAvdtpUUID = 0x0019;

static const TInt KObexProtocolUUID = 0x0008;

static const TInt KRFCommUUID = 0x0003;

// Service class UUIDs (add to these as necessary)

/** L2CAP UUID used for continuation tests*/

static const TUint32	KSdpContTestUUID = 0x100;

/** Serial Port UUID */

static const TInt KSerialPortUUID = 0x1101;

/** Dial Networking UUID */

static const TInt KDialUpNetworkingUUID = 0x1103;

/** General Networking UUID */

static const TInt KGenericNetworkingUUID = 0x1201;

/** Fax UUID */

static const TInt KFaxUUID = 0x1111;

/** Generic Telaphony UUID */

static const TInt KGenericTelephonyUUID = 0x1204;

/** Obex UUID */

static const TInt KObexUUID = 0x1105;

/** Attribute number for the Protocol Descriptor List */

static const TInt KProtocolDescriptorListUUID = 0x0004;

/** Public Browse Group UUID */

static const TInt KPublicBrowseGroupUUID = 0x1002;

/** Browse Group Descriptor Service Class UUID */

static const TInt KBrowseGroupDescriptorServiceClassUUID = 0x1001;

/** Service Discovery Server Service Class UUID */

static const TInt KServiceDiscoveryServerServiceClassUUID = 0x1000;

/** PAN Service Class UUID */

static const TInt KPanUUUID = 0x1115;

/** PAN NAP Service Class UUID */

static const TInt KPanNapUUID = 0x1116;

/** PAN GN Service Class UUID */

static const TInt KPanGnUUID = 0x1117;

/** Audio Source (service class) UUID */

static const TInt KAudioSourceUUID = 0x110a;

/** Audio Sink (service class) UUID */

static const TInt KAudioSinkUUID = 0x110b;

/** Remote control target (service class) UUID */

static const TInt KAVRemoteControlTargetUUID = 0x110c;

/** Advanced audio distribution (A2DP) (profile descriptor) UUID */

static const TInt KAdvancedAudioDistributionUUID = 0x110d;

/** Remote control (service class) UUID */

static const TInt KAVRemoteControlUUID = 0x110E;

/** Remote control controller (service class) UUID */

static const TInt KAVRemoteControlControllerUUID = 0x110F;

/** PBAP PSE Service Class UUID */

static const TInt KPbapPseUUID = 0x112F;

// Language codes, as per "ISO 639:1988 (E/F)"

/** Afar */

static const TInt16 KLanguageAfar = 0x6161; // aa

/** Abkhazian */

static const TInt16 KLanguageAbkhazian = 0x6162; // ab

/** Afrikaans */

static const TInt16 KLanguageAfrikaans = 0x6166; // af

/** Amharic */

static const TInt16 KLanguageAmharic = 0x616D; // am

/** Arabic */

static const TInt16 KLanguageArabic = 0x6172; // ar

/** Assamese */

static const TInt16 KLanguageAssamese = 0x6173; // as

/** Aymara */

static const TInt16 KLanguageAymara = 0x6179; // ay

/** Azerbaijani */

static const TInt16 KLanguageAzerbaijani = 0x617A; // az

/** Bashkir */

static const TInt16 KLanguageBashkir = 0x6261; // ba

/** Byelorussian */

static const TInt16 KLanguageByelorussian = 0x6265; // be

/** Bulgarian */

static const TInt16 KLanguageBulgarian = 0x6267; // bg

/** Bihari */

static const TInt16 KLanguageBihari = 0x6268; // bh

/** Bislama */

static const TInt16 KLanguageBislama = 0x6269; // bi

/** Bengali */

static const TInt16 KLanguageBengali = 0x626E; // bn - also Bangala

/** Tibetan */

static const TInt16 KLanguageTibetan = 0x626F; // bo

/** Breton */

static const TInt16 KLanguageBreton = 0x6272; // br

/** Catalan */

static const TInt16 KLanguageCatalan = 0x6361; // ca

/** Corsican */

static const TInt16 KLanguageCorsican = 0x636F; // co

/** Czech */

static const TInt16 KLanguageCzech = 0x6373; // cs

/** Welsh */

static const TInt16 KLanguageWelsh = 0x6379; // cy

/** Danish */

static const TInt16 KLanguageDanish = 0x6461; // da

/** German */

static const TInt16 KLanguageGerman = 0x6465; // de

/** Bhutani */

static const TInt16 KLanguageBhutani = 0x647A; // dz

/** Greek */

static const TInt16 KLanguageGreek = 0x656C; // el

/** English */

static const TInt16 KLanguageEnglish = 0x656E; // en

/** Esperanto */

static const TInt16 KLanguageEsperanto = 0x656F; // eo

/** Spanish */

static const TInt16 KLanguageSpanish = 0x6573; // es

/** Estonian */

static const TInt16 KLanguageEstonian = 0x6574; // et

/** Basque */

static const TInt16 KLanguageBasque = 0x6575; // eu

/** Persian */

static const TInt16 KLanguagePersian = 0x6661; // fa

/** Finnish */

static const TInt16 KLanguageFinnish = 0x6669; // fi

/** Fiji */

static const TInt16 KLanguageFiji = 0x666A; // fj

/** Faroese */

static const TInt16 KLanguageFaroese = 0x666F; // fo

/** French */

static const TInt16 KLanguageFrench = 0x6672; // fr

/** Frisian */

static const TInt16 KLanguageFrisian = 0x6679; // fy

/** Irish */

static const TInt16 KLanguageIrish = 0x6761; // ga

/** Scots Gaelic */

static const TInt16 KLanguageScotsGaelic = 0x6764; // gd

/** Galician */

static const TInt16 KLanguageGalician = 0x676C; // gl

/** Guarani */

static const TInt16 KLanguageGuarani = 0x676E; // gn

/** Gujarati */

static const TInt16 KLanguageGujarati = 0x6775; // gu

/** Hausa */

static const TInt16 KLanguageHausa = 0x6861; // ha

/** Hebrew */

static const TInt16 KLanguageHebrew = 0x6865; // he - formerly iw

/** Hindi */

static const TInt16 KLanguageHindi = 0x6869; // hi

/** Croatian */

static const TInt16 KLanguageCroatian = 0x6872; // hr

/** Hungarian */

static const TInt16 KLanguageHungarian = 0x6875; // hu

/** Armenian */

static const TInt16 KLanguageArmenian = 0x6879; // hy

/** Interlingua */

static const TInt16 KLanguageInterlingua = 0x6961; // ia

/** Indonesian */

static const TInt16 KLanguageIndonesian = 0x6964; // id - formerly in

/** Interlingue */

static const TInt16 KLanguageInterlingue = 0x6965; // ie

/** Inupiak */

static const TInt16 KLanguageInupiak = 0x696B; // ik

/** Icelandic */

static const TInt16 KLanguageIcelandic = 0x6973; // is

/** Italian */

static const TInt16 KLanguageItalian = 0x6974; // it

/** Inuktitut */

static const TInt16 KLanguageInuktitut = 0x6975; // iu

/** Japanese */

static const TInt16 KLanguageJapanese = 0x6A61; // ja

/** Javanese */

static const TInt16 KLanguageJavanese = 0x6A77; // jw

/** Georgian */

static const TInt16 KLanguageGeorgian = 0x6B61; // ka

/** Kazakh */

static const TInt16 KLanguageKazakh = 0x6B6B; // kk

/** Greenlandic */

static const TInt16 KLanguageGreenlandic = 0x6B6C; // kl

/** Cambodian */

static const TInt16 KLanguageCambodian = 0x6B6D; // km

/** Kannada */

static const TInt16 KLanguageKannada = 0x6B6E; // kn

/** Korean */

static const TInt16 KLanguageKorean = 0x6B6F; // ko

/** Kashmiri */

static const TInt16 KLanguageKashmiri = 0x6B73; // ks

/** Kurdish */

static const TInt16 KLanguageKurdish = 0x6B75; // ku

/** Kirghiz */

static const TInt16 KLanguageKirghiz = 0x6B79; // ky

/** Latin */

static const TInt16 KLanguageLatin = 0x6C61; // la

/** Lingala */

static const TInt16 KLanguageLingala = 0x6C6E; // ln

/** Laothian */

static const TInt16 KLanguageLaothian = 0x6C6F; // lo

/** Lithuanian */

static const TInt16 KLanguageLithuanian = 0x6C74; // lt

/** Latvian */

static const TInt16 KLanguageLatvian = 0x6C76; // lv - also Lettish

/** Malagasy */

static const TInt16 KLanguageMalagasy = 0x6D67; // mg

/** Maori */

static const TInt16 KLanguageMaori = 0x6D69; // mi

/** Macedonian */

static const TInt16 KLanguageMacedonian = 0x6D6B; // mk

/** Malayalam */

static const TInt16 KLanguageMalayalam = 0x6D6C; // ml

/** Mongolian */

static const TInt16 KLanguageMongolian = 0x6D6E; // mn

/** Moldavian */

static const TInt16 KLanguageMoldavian = 0x6D6F; // mo

/** Marathi */

static const TInt16 KLanguageMarathi = 0x6D72; // mr

/** Malay */

static const TInt16 KLanguageMalay = 0x6D73; // ms

/** Maltese */

static const TInt16 KLanguageMaltese = 0x6D74; // mt

/** Burmese */

static const TInt16 KLanguageBurmese = 0x6D79; // my

/** Nauru */

static const TInt16 KLanguageNauru = 0x6E61; // na

/** Nepali */

static const TInt16 KLanguageNepali = 0x6E65; // ne

/** Dutch */

static const TInt16 KLanguageDutch = 0x6E6C; // nl

/** Norwegian */

static const TInt16 KLanguageNorwegian = 0x6E6F; // no

/** Occitan */

static const TInt16 KLanguageOccitan = 0x6F63; // oc

/** Oromo */

static const TInt16 KLanguageOromo = 0x6F6D; // om - (Afan)

/** Oriya */

static const TInt16 KLanguageOriya = 0x6F72; // or

/** Punjabi */

static const TInt16 KLanguagePunjabi = 0x7061; // pa

/** Polish */

static const TInt16 KLanguagePolish = 0x706C; // pl

/** Pashto */

static const TInt16 KLanguagePashto = 0x7073; // ps

/** Portuguese */

static const TInt16 KLanguagePortuguese = 0x7074; // pt

/** Quechua */

static const TInt16 KLanguageQuechua = 0x7175; // qu

/** Rhaeto Romance */

static const TInt16 KLanguageRhaetoRomance = 0x726D; // rm

/** Kirundi */

static const TInt16 KLanguageKirundi = 0x726E; // rn

/** Romanian */

static const TInt16 KLanguageRomanian = 0x726F; // ro

/** Russian */

static const TInt16 KLanguageRussian = 0x7275; // ru

/** Kinyarwanda */

static const TInt16 KLanguageKinyarwanda = 0x7277; // rw

/** Sanskrit */

static const TInt16 KLanguageSanskrit = 0x7361; // sa

/** Sindhi */

static const TInt16 KLanguageSindhi = 0x7364; // sd

/** Sangho */

static const TInt16 KLanguageSangho = 0x7367; // sg

/** SerboCroatian */

static const TInt16 KLanguageSerboCroatian = 0x7368; // sh

/** Sinhalese */

static const TInt16 KLanguageSinhalese = 0x7369; // si

/** Slovak */

static const TInt16 KLanguageSlovak = 0x736B; // sk

/** Slovenian */

static const TInt16 KLanguageSlovenian = 0x736C; // sl

/** Samoan */

static const TInt16 KLanguageSamoan = 0x736D; // sm

/** Shona */

static const TInt16 KLanguageShona = 0x736E; // sn

/** Somali */

static const TInt16 KLanguageSomali = 0x736F; // so

/** Albanian */

static const TInt16 KLanguageAlbanian = 0x7371; // sq

/** Serbian */

static const TInt16 KLanguageSerbian = 0x7372; // sr

/** Siswati */

static const TInt16 KLanguageSiswati = 0x7373; // ss

/** Sesotho */

static const TInt16 KLanguageSesotho = 0x7374; // st

/** Sundanese */

static const TInt16 KLanguageSundanese = 0x7375; // su

/** Swedish */

static const TInt16 KLanguageSwedish = 0x7376; // sv

/** Swahili */

static const TInt16 KLanguageSwahili = 0x7377; // sw

/** Tamil */

static const TInt16 KLanguageTamil = 0x7461; // ta

/** Telugu */

static const TInt16 KLanguageTelugu = 0x7465; // te

/** Tajik */

static const TInt16 KLanguageTajik = 0x7467; // tg

/** Thai */

static const TInt16 KLanguageThai = 0x7468; // th

/** Tigrinya */

static const TInt16 KLanguageTigrinya = 0x7469; // ti

/** Turkmen */

static const TInt16 KLanguageTurkmen = 0x746B; // tk

/** Tagalog */

static const TInt16 KLanguageTagalog = 0x746C; // tl

/** Setswana */

static const TInt16 KLanguageSetswana = 0x746E; // tn

/** Tonga */

static const TInt16 KLanguageTonga = 0x746F; // to

/** Turkish */

static const TInt16 KLanguageTurkish = 0x7472; // tr

/** Tsonga */

static const TInt16 KLanguageTsonga = 0x7473; // ts

/** Tatar */

static const TInt16 KLanguageTatar = 0x7474; // tt

/** Twi */

static const TInt16 KLanguageTwi = 0x7477; // tw

/** Uighur */

static const TInt16 KLanguageUighur = 0x7567; // ug

/** Ukrainian */

static const TInt16 KLanguageUkrainian = 0x756B; // uk

/** Urdu */

static const TInt16 KLanguageUrdu = 0x7572; // ur

/** Uzbek */

static const TInt16 KLanguageUzbek = 0x757A; // uz

/** Vietnamese */

static const TInt16 KLanguageVietnamese = 0x7669; // vi

/** Volapuk */

static const TInt16 KLanguageVolapuk = 0x766F; // vo

/** Wolof */

static const TInt16 KLanguageWolof = 0x776F; // wo

/** Xhosa */

static const TInt16 KLanguageXhosa = 0x7868; // xh

/** Yiddish */

static const TInt16 KLanguageYiddish = 0x7969; // yi - formerly ji

/** Yoruba */

static const TInt16 KLanguageYoruba = 0x796F; // yo

/** Zhuang */

static const TInt16 KLanguageZhuang = 0x7A61; // za

/** Chinese */

static const TInt16 KLanguageChinese = 0x7A68; // zh

/** Zulu */

static const TInt16 KLanguageZulu = 0x7A75; // zu

//***********************************************************************/

//

//   SDP database server API

//

//***********************************************************************/

/** Typedef for a TSdpAttributeID package buf */

typedef TPckgBuf<TSdpAttributeID> TSdpAttributeIDPckgBuf;

/** Handle to a service record. */

typedef TUint32 TSdpServRecordHandle;

/** Typedef for a TSdpServRecordHandle package buf */

typedef TPckgBuf<TSdpServRecordHandle> TSdpServRecordHandlePckgBuf;

NONSHARABLE_CLASS(RSdp) : public RSessionBase

/** Provides a session to the Service Discovery Database.

Used to create subsessions to database functionality. A clients must create

and connect a session, before using a RSdpDatabase subsession to access the

database.

@see RSdpDatabase */

	{

public:

	IMPORT_C RSdp();

	IMPORT_C TInt Connect();

	IMPORT_C TVersion Version() const;

	IMPORT_C void ResourceCountMarkStart();

	IMPORT_C void ResourceCountMarkEnd();

	IMPORT_C TInt ResourceCount();

	IMPORT_C TInt __DbgMarkHeap();

	IMPORT_C TInt __DbgCheckHeap(TInt aCount);

	IMPORT_C TInt __DbgMarkEnd(TInt aCount);

	IMPORT_C TInt __DbgFailNext(TInt aCount);

private:

	// This data padding has been added to help prevent future binary compatibility breaks	

	// Neither iPadding1 nor iPadding2 have been zero'd because they are currently not used

	TUint32     iPadding1; 

	TUint32     iPadding2; 	

	};

NONSHARABLE_CLASS(RSdpSubSession) : public RSubSessionBase

/** Base class used in the derivation of RSdpDatabase. 

The class contains basic subssession functionality. It has no user accessible

functions. */

	{

public:

	/** Opens subsession on an RSdp session

    @param aSession The session on which the subsession is being opened.

    */

	IMPORT_C virtual TInt Open(RSdp& aSession)=0;

	/** Closes subsession */

	IMPORT_C virtual void Close()=0;

private:

	// This data padding has been added to help prevent future binary compatibility breaks	

	// Neither iPadding1 nor iPadding2 have been zero'd because they are currently not used

	TUint32     iPadding1; 

	TUint32     iPadding2; 		

	};

class CSdpAttrValueDES;

class CSdpAttrValue;

NONSHARABLE_CLASS(RSdpDatabase) : public RSdpSubSession

/** Subsession to the SDP through which service records and their attributes can 

be added, deleted, and updated. */

	{

public:

	IMPORT_C RSdpDatabase();

	IMPORT_C TInt Open(RSdp& aSession);

	IMPORT_C void Close();

	IMPORT_C void CreateServiceRecordL(const TUUID& aUUID, TSdpServRecordHandle& aHandle);

	IMPORT_C void CreateServiceRecordL(CSdpAttrValueDES& aUUIDList, TSdpServRecordHandle& aHandle);

	IMPORT_C void UpdateAttributeL(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID, CSdpAttrValue& aAttrValue);

	IMPORT_C void UpdateAttributeL(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID, TUint aUintValue);

	IMPORT_C void UpdateAttributeL(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID, const TDesC16& aDesCValue);

	IMPORT_C void UpdateAttributeL(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID, const TDesC8& aDesCValue);

	IMPORT_C void DeleteAttributeL(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID);

	IMPORT_C void DeleteAttribute(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID);

	IMPORT_C void DeleteRecordL(TSdpServRecordHandle aHandle);

	IMPORT_C void DeleteRecord(TSdpServRecordHandle aHandle);

private:

	HBufC8* iBuffer; //used for synchronous requests (could have been local)

	// This data padding has been added to help prevent future binary compatibility breaks	

	// Neither iPadding1 nor iPadding2 have been zero'd because they are currently not used

	TUint32     iPadding1; 

	TUint32     iPadding2; 		

	};

class MSdpElementBuilder

/** Constructs an attribute value, or a set of attributes, from multiple data elements.

The builder interface is used for building single attribute values, and sets of attribute 

value, attribute ID pairs, as for example in a service record.

In particular, the builder interface can be implemented to receive the results from 

CSdpAgent attribute queries.

Each member function itself returns an MSdpElementBuilder interface that can 

then be used to add further elements. 

For more on the format of attribute values, see [BS1 Service Discovery Protocol 

3].

Note that the interface defines each function to leave with the error KErrGeneral.

@see CSdpAgent::AttributeRequestL() */

	{

public:

	IMPORT_C virtual MSdpElementBuilder* BuildUnknownL(TUint8 aType, TUint8 aSizeDesc, const TDesC8& aData);

	IMPORT_C virtual MSdpElementBuilder* BuildNilL();

	IMPORT_C virtual MSdpElementBuilder* BuildUintL(const TDesC8& aUint);

	IMPORT_C virtual MSdpElementBuilder* BuildIntL(const TDesC8& aInt);

	IMPORT_C virtual MSdpElementBuilder* BuildUUIDL(const TUUID& aUUID);

	IMPORT_C virtual MSdpElementBuilder* BuildBooleanL(TBool aBool);

	IMPORT_C virtual MSdpElementBuilder* BuildStringL(const TDesC8& aString);

	IMPORT_C virtual MSdpElementBuilder* BuildDESL();  // Must not return NULL

	IMPORT_C virtual MSdpElementBuilder* BuildDEAL();  // ditto

	IMPORT_C virtual MSdpElementBuilder* StartListL(); // ditto

	IMPORT_C virtual MSdpElementBuilder* EndListL();

	IMPORT_C virtual MSdpElementBuilder* BuildURLL(const TDesC8& aURL);

    /**

 	 Returns a null aObject if the extension is not implemented, or a pointer to another interface if it is.

	 @param aInterface UID of the interface to return

	 @param aObject the container for another interface as specified by aInterface

	 */

	IMPORT_C void MSEB_ExtensionInterfaceL(TUid aInterface, void*& aObject);	

	};

/** Types of attribute data elements. */

enum TSdpElementType

	{

	/** Null type. */

	ETypeNil		=  0,

	/** Unsigned integer. */

	ETypeUint		=  1,

	/** Signed integer. */

	ETypeInt		=  2,

	/** UUID. */

	ETypeUUID		=  3,

	/** Text string. */

	ETypeString		=  4,

	/** Boolean. */

	ETypeBoolean	=  5,

	/** Data element sequence. */

	ETypeDES		=  6,

	/** Data element alternative. */

	ETypeDEA		=  7,

	/** URL. */

	ETypeURL		=  8,

	/** Outside SDP reserved range. */

	ETypeEncoded	= 32,	// Outside SDP reserved range

	};

class MSdpAttributeValueVisitor;

NONSHARABLE_CLASS(CSdpAttrValue) : public CBase

/** Base class for classes that encapsulate SDP attributes values.

Sub-classes of this wrap specific types of SDP service record attributes. 

For example, CSdpBoolean derives from CSdpAttrValue to encapsulate boolean 

attributes. The base class defines getters for all types: for example, it 

declares a function Bool() that returns the attribute value as a TBool. Note 

though that the function would panic unless called on actual CSdpBoolean.

A common base class allows attributes of all types to be used polymorphically. 

You can use CSdpAttrValue's Type() function to find the actual type being 

used, and upcast the pointer appropriately. */

	{

public:

	CSdpAttrValue();

	virtual ~CSdpAttrValue();

	/** Gets the attribute type.

	@return Attribute type */

	virtual TSdpElementType Type() const=0;

	/** Gets the size of the attribute.

	@return Size of the attribute in bytes */

	virtual TUint DataSize() const=0;

	// getter interface

	virtual TUint Uint() const;

	virtual TInt Int() const;

	virtual TBool DoesIntFit() const;

	virtual TInt Bool() const;

	virtual const TUUID &UUID() const;

	virtual const TPtrC8 Des() const;

	virtual void AcceptVisitorL(MSdpAttributeValueVisitor& aVisitor);

	IMPORT_C void Uint64(TUint64& aValue) const; 

 	IMPORT_C void Uint128(TUint64& aLo, TUint64& aHi) const;

protected:

	TInt Extension_(TUint aExtensionId, TAny *&a0, TAny *a1);

	};

/** Base class for classes that specify lists of attribute data elements.

It implements the MSdpElementBuilder interface to build data elements into 

an attribute value.

@see CSdpAttrValueDEA

@see CSdpAttrValueDES */

NONSHARABLE_CLASS(CSdpAttrValueList) : public CSdpAttrValue, public MSdpElementBuilder

	{

public:

	virtual ~CSdpAttrValueList();

	virtual void AcceptVisitorL(MSdpAttributeValueVisitor& aVisitor);

	virtual TUint DataSize() const;

	IMPORT_C void AppendValueL(CSdpAttrValue* aValue);

	// MSdpElementBuilder interface

	/** Adds an element of any type.

	@param aType Type descriptor

	@param aSizeDesc Size descriptor

	@param aData Data field

	@return Attribute value with added element */

	virtual MSdpElementBuilder* BuildUnknownL(TUint8 aType, TUint8 aSizeDesc, const TDesC8& aData);

	virtual MSdpElementBuilder* BuildNilL();

	virtual MSdpElementBuilder* BuildUintL(const TDesC8& aUint);

	virtual MSdpElementBuilder* BuildIntL(const TDesC8& aInt);

	virtual MSdpElementBuilder* BuildUUIDL(const TUUID& aUUID);

	virtual MSdpElementBuilder* BuildBooleanL(TBool aBool);

	virtual MSdpElementBuilder* BuildStringL(const TDesC8& aString);

	virtual MSdpElementBuilder* BuildDESL();

	virtual MSdpElementBuilder* BuildDEAL();

	virtual MSdpElementBuilder* StartListL();

	virtual MSdpElementBuilder* EndListL();

	virtual MSdpElementBuilder* BuildURLL(const TDesC8& aString);

	virtual MSdpElementBuilder* BuildEncodedL(const TDesC8& aString);

protected:

	CSdpAttrValueList(MSdpElementBuilder *aBuilder);

	void ConstructL();

protected:

	/** Array of attribute values contained in this CSdpAttrValueList class*/

	CArrayPtr<CSdpAttrValue> *iList;

private:

	MSdpElementBuilder *iParent;

	};

NONSHARABLE_CLASS(CSdpAttrValueNil) : public CSdpAttrValue

/** A null type data attribute. */

	{

public:

	IMPORT_C static CSdpAttrValueNil *NewNilL();

	virtual ~CSdpAttrValueNil();

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

private:

	CSdpAttrValueNil();

	};

/** Max size for an SDP Uint attribute value in bytes */

static const TInt KSdpMaxUintSize = 16;

NONSHARABLE_CLASS(CSdpAttrValueUint) : public CSdpAttrValue

/** A unsigned integer value of an attribute.

The value can be up to 128 bits in size. You need to choose to use either Uint() for up to 32 bit size,

Uint64() for up to 64 bit size or Uint128() for up to 128 bit size. The size can be found using DataSize().

If the incorrect function is used the code will panic. 

*/

	{

public:

	IMPORT_C static CSdpAttrValueUint* NewUintL(const TDesC8 &aUint);

	virtual ~CSdpAttrValueUint();

	IMPORT_C void SetUintValue(const TDesC8& aValue);

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

	TUint Uint() const;

	virtual TBool DoesIntFit() const;

	virtual const TPtrC8 Des() const;

private:

	TInt Extension_(TUint aExtensionId, TAny *&a0, TAny *a1);

	CSdpAttrValueUint(const TDesC8 & aUint);

private:

	TBuf8<KSdpMaxUintSize> iUint;

	};

/** 

Max size for an SDP Int attribute value in bytes 

The new value is KSdpMaxIntSize

@deprecated

*/

static const TInt KMaxIntSize  = 16;

/** 

Max size for an SDP Int attribute value in bytes 

*/

static const TInt KSdpMaxIntSize  = 16;

NONSHARABLE_CLASS(CSdpAttrValueInt) : public CSdpAttrValue

/** A signed integer value of an attribute.

The value can be up to 128 bits in size. */

	{

public:

	IMPORT_C static CSdpAttrValueInt* NewIntL(const TDesC8 &aInt);

	virtual ~CSdpAttrValueInt();

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

	virtual TInt Int() const;

	virtual TBool DoesIntFit() const;

	virtual const TPtrC8 Des() const;

private:

	CSdpAttrValueInt(const TDesC8 & aInt);

private:

	TBuf8<KSdpMaxIntSize> iInt;

	};

NONSHARABLE_CLASS(CSdpAttrValueUUID) : public CSdpAttrValue

/** A UUID value of an attribute.

The value can be up to 128 bits in size. */

	{

public:

	IMPORT_C static CSdpAttrValueUUID* NewUUIDL(const TUUID& aUUID);

	virtual ~CSdpAttrValueUUID();

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

	// getters

	virtual const TUUID &UUID() const;

	virtual const TPtrC8 Des() const;

private:

	CSdpAttrValueUUID(const TUUID& aUUID);

private:

	TUUID iUUID;

	};

NONSHARABLE_CLASS(CSdpAttrValueString) : public CSdpAttrValue

/** A Text String value of an attribute.

The encoding of the string is up to the user. The interpretation of the encoding 

is enabled using facilities in SDP. */

	{

public:

	IMPORT_C static CSdpAttrValueString* NewStringL(const TDesC8& aString);

	virtual ~CSdpAttrValueString();

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

	virtual const TPtrC8 Des() const;

private:

	CSdpAttrValueString();

	void ConstructL(const TDesC8& aString);

private:

	HBufC8 *iBuffer;

	};

NONSHARABLE_CLASS(CSdpAttrValueBoolean) : public CSdpAttrValue

/** A Boolean value of an attribute. */

	{

public:

	IMPORT_C static CSdpAttrValueBoolean *NewBoolL(TBool aBool);

	virtual ~CSdpAttrValueBoolean();

	virtual TSdpElementType Type() const;

	virtual TUint DataSize() const;

	virtual TBool Bool() const;

private:

	CSdpAttrValueBoolean(TBool aBool);

private:

	TBool iBool;

	};

NONSHARABLE_CLASS(CSdpAttrValueDES) : public CSdpAttrValueList

/** A Data element sequence (DES) value of an attribute.

A DES can contain other values within it, including other sequences. This 

enables arbitrary tree structures to be created.

Most of the functionality is supplied by the base class CSdpAttrValueList. */

	{

public:

	IMPORT_C static CSdpAttrValueDES* NewDESL(MSdpElementBuilder* aBuilder);

	virtual TSdpElementType Type() const;

private:

	CSdpAttrValueDES(MSdpElementBuilder *aBuilder);

	};

NONSHARABLE_CLASS(CSdpAttrValueDEA) : public CSdpAttrValueList

/** A Data element alternative (DEA) value of an attribute: this is an attribute 

whose value is a sequence of data elements from which one data element is 

to be selected

Most of the functionality is supplied by the base class CSdpAttrValueList. */

	{

public:

	IMPORT_C static CSdpAttrValueDEA* NewDEAL(MSdpElementBuilder* aBuilder);

	virtual TSdpElementType Type() const;

private:

	CSdpAttrValueDEA(MSdpElementBuilder *aBuilder);

	};

NONSHARABLE_CLASS(CSdpAttrValueURL) : public CSdpAttrValue

/** A URL value of an attribute. */

	{

public:

	IMPORT_C static CSdpAttrValueURL* NewURLL(const TDesC8& aString);

	virtual ~CSdpAttrValueURL();

	virtual TSdpElementType Type() const;

	virtual const TPtrC8 Des() const;

	virtual TUint DataSize() const;

private:

	CSdpAttrValueURL();

	void ConstructL(const TDesC8& aString);

private:

	HBufC8 *iBuffer;

	};

class MSdpAttributeValueVisitor

/** Abstract interface that can be implemented to receive an enumeration of the 

values in an attribute list.

The class member functions are called by an CSdpAttrValue (or one of its sub-classes) 

object when CSdpAttrValue::AcceptVisitorL() is called.

Note that:

When AcceptVisitorL() is called on attributes that are not lists (not DEA 

or DES), only VisitAttributeValueL() is called, passing the attribute value 

object itself (i.e. *this), and the value attribute type.

When AcceptVisitorL() is called on attributes that are lists (DEA or DES), 

VisitAttributeValueL() is called for each member of the list

This implements the standard Visitor pattern.

@see CSdpAttrValue::AcceptVisitorL() */

	{

public:

	/** Called to pass an attribute value.

	@param aValue Attribute value

	@param aType Value type */

    virtual void VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)=0;

	/** Called to indicate the start of a list of attribute values.

	This call is followed by a call to VisitAttributeValueL() for each attribute 

	value in the list, and concluded by a call to EndList().

	@param aList Attribute value list */

    virtual void StartListL(CSdpAttrValueList &aList)=0;

	/** Called to indicate the end of a list of attribute values. */

    virtual void EndListL()=0;

    /**

 	 Returns a null aObject if the extension is not implemented, or a pointer to another interface if it is.

	 @param aInterface UID of the interface to return

	 @param aObject the container for another interface as specified by aInterface

	 */

	IMPORT_C virtual void MSAVV_ExtensionInterfaceL(TUid aInterface, void*& aObject);    

	};

class SdpUtil

/**Integer Putter/Getter Utility Class 

Utility class for putting integer values into/getting integer values out of descriptors  */

	{

public:

	IMPORT_C static TUint GetUint(const TDesC8& aData);

	IMPORT_C static void PutUint(TUint8* aPtr, TInt64 aInt, TInt aNumberOfBytes);

	IMPORT_C static void PutUint64(TUint8* aPtr, const TUint64& aNumber);			

	IMPORT_C static void GetUint64(const TDesC8& aData, TUint64& aNumber);

	IMPORT_C static void PutUint128(TUint8* aPtr, const TUint64& aLo, const TUint64& aHi);	

	IMPORT_C static void GetUint128(const TDesC8& aData, TUint64& aLo, TUint64& aHi);	

	};

/**Integer to Descriptor Convertor

Utility class to convert EPOC integers into TDesC8's, in the correct

format for passing to the BuildIntL and BuildUintL members in SDP.

This is effectively a Big-endian variant of TPckgBuf.

*/

template<class T>

class TSdpIntBuf : public TBufC8<sizeof(T)>

	{

public:

	inline TSdpIntBuf(const T& aRef);

	};

/**Speciality of Integer to Descriptor Convertor for TUint64s*/

TEMPLATE_SPECIALIZATION class TSdpIntBuf<TUint64> :public TBufC8<sizeof(TUint64)>

	{

public:

	IMPORT_C TSdpIntBuf(const TUint64& aRef);

	};

/**Speciality of Integer to Descriptor Convertor for TUint32s*/

TEMPLATE_SPECIALIZATION class TSdpIntBuf<TUint32> : public TSdpIntBuf<TUint>

	{

public:

	IMPORT_C TSdpIntBuf(const TUint32& aRef);

	};