// 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 <bttypes.h>
#include "btsocketpanic.h"
static const TUint8 KBluetoothBaseUUID[] =
{
/*Replaced by short UUID: 0x00, 0x00, 0x00, 0x00*/
0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB
};
static const TUint8 KSymbianBaseUUID[] =
{
/*Replaced by TUid: 0x00, 0x00, 0x00, 0x00*/
0x00, 0x00, 0x10, 0x00, 0x80, 0x00,
0x00, 0x00, 0x1B, 0x20, 0xC7, 0xAE
};
/**
Default constructor.
Sets the UUID to all zeros.
**/
EXPORT_C TUUID::TUUID()
{
iUUID.Reset();
}
/**
Construct UUID from TUint32.
The Bluetooth base UUID will be appended to the value passed.
Use this form of constructor for building 16 or 32 bit short-form
UUIDs.
@param aLong is a Big-endian format TUint32 containing the UUID.
**/
EXPORT_C TUUID::TUUID(TUint32 aLong)
{
BigEndian::Put32(iUUID.Begin(), aLong);
Mem::Copy(iUUID.Begin()+4, KBluetoothBaseUUID, sizeof(KBluetoothBaseUUID));
}
/**
128 bit UUID constructor.
Use this constructor to build full length 128 bit UUIDs.
@param aHH Highest order word (bits 96 - 127) in its Big-endian format
@param aHL Second highest order word (bits 64 - 95) in its Big-endian format
@param aLH Secong lowset order word (bits 32 - 63) in its Big-endian format
@param aLL Low order word (bits 0 - 31) in its Big-endian format
**/
EXPORT_C TUUID::TUUID(TUint32 aHH, TUint32 aHL, TUint32 aLH, TUint32 aLL)
{
BigEndian::Put32(&iUUID[0], aHH);
BigEndian::Put32(&iUUID[4], aHL);
BigEndian::Put32(&iUUID[8], aLH);
BigEndian::Put32(&iUUID[12],aLL);
}
/**
Set Bluetooth UUID from an EPOC UUID.
Uses a well known reserved range. This defines a one-to-one
mapping between all EPOC UIDs and and a range of Bluetooth UUID.
Base UUID used is 00000000-0000-1000-8000-00001B20C7AE; the first four
bytes are replaced by the 32 bit Sybmian OS Uid, in big-endian form.
@param aUid EPOC UID to set this Bluetooth UUID from
**/
EXPORT_C TUUID::TUUID(const TUid& aUid)
{
BigEndian::Put32(iUUID.Begin(), aUid.iUid);
Mem::Copy(iUUID.Begin()+4, KSymbianBaseUUID, sizeof(KSymbianBaseUUID));
}
/**
Set the UUID from a binary descriptor.
Can accept a 2, 4, or 16 byte descriptor.
Any other value will cause a leave with @c KErrArgument.
If a 2 or 4 byte descriptor is set, the rest of the UUID will be filled
with the Bluetooth well-known base UUID.
@param aDes The binary descriptor. Note that the descriptor is interpretted to be in Big-endian format,
i.e. index 0 holds the most significant byte.
@leave This method will leave if an error occurs.
**/
EXPORT_C void TUUID::SetL(const TDesC8& aDes)
{
TPtr8 dst(iUUID.Begin(), KSdpUUIDMaxLength);
switch(aDes.Length())
{
// only 2 bytes given - so fill first two terms in iUUUD array with zeros
// then fall through to fill next two terms with contents of aDes
// then last 12 terms with default extension
case 2:
dst.FillZ(2); //fill first two bytes of 'dst' with zeros
// if fall through to here see comment above 'case 2'
// otherwise: 4 bytes given - so fill first four terms in iUUUD array with contents of aDes
// then last 12 terms with default extension
case 4:
dst.Append(aDes);
dst.Append(KBluetoothBaseUUID, sizeof(KBluetoothBaseUUID));
break;
// all 16 bytes given - copy them all to the iUUID array.
case 16:
dst.Copy(aDes);
break;
default:
User::Leave(KErrArgument);
}
}
/**
Returns the full 128 bit version of the UUID.
@return The long form version of the UUID.
**/
EXPORT_C const TPtrC8 TUUID::LongForm() const
{
return TPtrC8(iUUID.Begin(), KSdpUUIDMaxLength);
}
/**
Get the smallest version the UUID will compress down to.
Might be 2, 4, or 16 bytes.
If 2 or 4 bytes, the ommitted bytes are implicity those
from the Bluetooth base UUID.
@return TPtrC8 pointing to 2, 4, or 16 bytes of significant address.
**/
EXPORT_C const TPtrC8 TUUID::ShortestForm() const
{
TPtrC8 uuid=LongForm();
TInt minSize = MinimumSize();
switch (minSize)
{
case 16:
// 128 bit
return uuid;
case 4:
// 32 bit
return uuid.Left(4);
}
// 16 bit version
return uuid.Mid(2,2);
}
// HACKME used to hack the size of the TUUID returned, see AttrValue
EXPORT_C const TPtrC8 TUUID::Des() const
{
return ShortestForm();
}
/**
* Return the UUID with a specified length.
*
* If 2 or 4 bytes, the ommitted bytes are implicity those from the Bluetooth
* base UUID.
*
* @param aLength The required length (2, 4 or 16 bytes).
* @return TPtrC8 pointing to 2, 4, or 16 bytes of significant UUID data.
* @leave KErrArgument The UUID length requested is invalid.
* @leave KErrTotalLossOfPrecision The UUID minimum size is less than the requested size.
* @deprecated use TUUID::SpecifiedLengthL() that implements the right size comparison logic
*/
EXPORT_C const TPtrC8 TUUID::FixedLengthL(TInt aLength) const
{
TPtrC8 uuid=LongForm();
TInt minSize = MinimumSize();
if (minSize < aLength)
User::Leave(KErrTotalLossOfPrecision);
switch (aLength)
{
case 2:
return uuid.Mid(2,2);
case 4:
return uuid.Left(4);
case 16:
// Will always be sufficient to represent this UUID.
// Rather than returning directly, break out of switch
// to convince compiler that function will always return a value.
break;
default:
User::Leave(KErrArgument);
}
return uuid;
}
/**
* Returns the minimum size of this UUID.
*/
EXPORT_C TInt TUUID::MinimumSize() const
{
TPtrC8 uuid=LongForm();
TInt minSize = 16;
if (uuid.Mid(4) == TPtrC8(KBluetoothBaseUUID, sizeof(KBluetoothBaseUUID)))
minSize = 4;
if ((minSize == 4) && (BigEndian::Get16(uuid.Ptr()) == 0))
minSize = 2;
return minSize;
}
/**
Comparison operator.
@param aUUID Object to compare to this.
@return ETrue is aUUID is the same as this, EFalse if not.
*/
EXPORT_C TBool TUUID::operator==(const TUUID& aUUID) const
{
return Mem::Compare(iUUID.Begin(), KSdpUUIDMaxLength, aUUID.iUUID.Begin(), KSdpUUIDMaxLength)==0;
}
/**
Inequality operator.
@param aUUID Object to compare to this.
@return EFalse is aUUID is the same as this, ETrue if not.
*/
EXPORT_C TBool TUUID::operator!=(const TUUID& aUUID) const
{
return !(*this==aUUID);
}
/**
Access a single element of the UUID.
@param aIndex The index of the element to access.
@return The element. The reference remains valid as long as this object is in scope.
*/
EXPORT_C const TUint8 &TUUID::operator[](TInt aIndex) const
{
return iUUID[aIndex];
}
/**
Access a single element of the UUID.
@param aIndex The index of the element to access.
@return The element. The reference remains valid as long as this object is in scope.
*/
EXPORT_C TUint8 &TUUID::operator[](TInt aIndex)
{
return iUUID[aIndex];
}
/**
* Return the UUID with a specified length.
*
* Does not allow compressing a UUID to less than its shortest form.
* If 2 or 4 bytes, the ommitted bytes are implicity those from the Bluetooth
* base UUID.
*
* @param aLength The required length (2, 4 or 16 bytes).
* @return TPtrC8 pointing to 2, 4, or 16 bytes of significant UUID data.
* @leave KErrArgument The UUID length requested is invalid.
* @leave KErrTotalLossOfPrecision The UUID cannot be compressed to the requested length.
*/
EXPORT_C const TPtrC8 TUUID::SpecifiedLengthL(TInt aLength) const
{
TPtrC8 uuid=LongForm();
TInt minSize = MinimumSize();
if (aLength < minSize)
User::Leave(KErrTotalLossOfPrecision);
switch (aLength)
{
case 2:
return uuid.Mid(2,2);
case 4:
return uuid.Left(4);
case 16:
// Will always be sufficient to represent this UUID.
// Rather than returning directly, break out of switch
// to convince compiler that function will always return a value.
break;
default:
User::Leave(KErrArgument);
}
return uuid;
}
/**
Set the UUID from a binary descriptor containing Little-endian format UUID.
Can accept a 2, 4, or 16 byte descriptor.
Any other value will cause a leave with @c KErrArgument.
If a 2 or 4 byte descriptor is set, the rest of the UUID will be filled
with the Bluetooth well-known base UUID.
@param aDes The binary descriptor. Note that the descriptor is interpretted to be in Little-endian format,
i.e. index 0 holds the most significant byte.
@leave This method will leave if an error occurs.
**/
EXPORT_C void TUUID::SetFromLittleEndianL(const TDesC8& aDes)
{
TBuf8<KSdpUUIDMaxLength> buf;
TInt length = aDes.Length();
__ASSERT_ALWAYS(length <= KSdpUUIDMaxLength, User::Leave(KErrArgument));
for(TInt i = length - 1; i >=0 ; i--)
{
buf.Append(aDes[i]);
}
SetL(buf);
}
// ------ RUUIDContainer --------------------------------------------------------------------------
EXPORT_C void RUUIDContainer::Close()
{
iUUIDs.Close();
}
EXPORT_C void RUUIDContainer::Reset()
{
iUUIDs.Reset();
iUUIDs.Compress();
}
EXPORT_C TInt RUUIDContainer::Count() const
{
return iUUIDs.Count();
}
/**
Check if a particular TUUID is present in the RUUIDContainer
@param aUuid the TUUID to be looked up in the container class
@return ETrue if it is present otherwise EFalse
*/
EXPORT_C TBool RUUIDContainer::IsPresent(const TUUID& aUuid) const
{
TBool ret = EFalse;
TUint count = iUUIDs.Count();
for (TUint i = 0; i < count; i++)
{
if (aUuid == iUUIDs[i])
{
ret = ETrue;
break;
}
}
return ret;
}
/**
Add an TUUID into RUUIDContainer
@param aUuid the TUUID to be added into the container class
@return a system wide error code.
*/
EXPORT_C TInt RUUIDContainer::Add(const TUUID& aUuid)
{
if (!IsPresent(aUuid))
{
return iUUIDs.Append(aUuid);
}
else
{
return KErrAlreadyExists;
}
}
/**
Access a single UUID.
@param aIndex The index of the UUID to access.
@return The UUID. The reference remains valid as long as this object is in scope.
*/
EXPORT_C const TUUID &RUUIDContainer::At(TInt aIndex) const
{
return iUUIDs[aIndex];
}
/**
Access a single UUID.
@param aIndex The index of the UUID to access.
@return The UUID. The reference remains valid as long as this object is in scope.
*/
EXPORT_C const TUUID &RUUIDContainer::operator[](TInt aIndex) const
{
return iUUIDs[aIndex];
}
/**
Access a single UUID.
@param aIndex The index of the UUID to access.
@return The UUID. The reference remains valid as long as this object is in scope.
*/
EXPORT_C TUUID &RUUIDContainer::operator[](TInt aIndex)
{
return iUUIDs[aIndex];
}
EXPORT_C void RExtendedInquiryResponseUUIDContainer::Close()
{
iUUIDs.Close();
}
/**
Retrieve the UUID container class.
@return RUUIDContainer, the UUID container class, which contains a set of UUIDs.
*/
EXPORT_C RUUIDContainer& RExtendedInquiryResponseUUIDContainer::UUIDs()
{
return iUUIDs;
}
/**
Check if the Extended Inquiry Response has a complete set of UUIDs.
@param aType a specifc type of UUID. It indicates which type of UUID the check will be carried upon.
This could be 16 bit, 32 bit or 128 bit TUUID.
@return the result of the check, ETrue means it's a complete set of UUIDs, otherwise EFalse.
*/
EXPORT_C TBool RExtendedInquiryResponseUUIDContainer::GetCompleteness(TUUIDType aType) const
{
// Check the bit for this UUID type. If set,
// data is partial, else data is complete
TInt completeness = iCompleteness & aType;
if (completeness > 0)
{
return EFalse;
}
return ETrue;
}
/**
Set the completeness for a set of specific type UUID (16, 32 or 128 bit UUID) in Extended Inquiry Response.
@param aType a specifc type of UUID. This could be 16 bit, 32 bit or 128 bit TUUID.
@param aIsComplete ETrue means it's a complete set of UUIDs, otherwise EFalse.
*/
EXPORT_C void RExtendedInquiryResponseUUIDContainer::SetCompleteness(TUUIDType aType, TBool aIsComplete)
{
TInt setcomp = 0;
if (aIsComplete == EFalse)
{
setcomp = aType;
}
// Set or clear the bit for this UUID type.
// If set, data is partial, else data is complete
iCompleteness &= ~(aType);
iCompleteness ^= setcomp;
}
//EOF