// Copyright (c) 1999-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 <btdevice.h>

#include <utf.h>

inline void __BTDEBUGGER()

// needed to call __DEBUGGER inside an __ASSERT

	{

	__DEBUGGER()

	}

#define __BT_BITMASK__(length) ((1 << (length)) - 1)

enum TBTDeviceClassV1

	{

	EMajorServiceLength = 11,

	EMajorDeviceLength = 5,

	EMinorDeviceLength = 6,

	EFormatTypeLength = 2,

	EMajorServiceMask = __BT_BITMASK__(EMajorServiceLength),

	EMajorDeviceMask = __BT_BITMASK__(EMajorDeviceLength),

	EMinorDeviceMask = __BT_BITMASK__(EMinorDeviceLength),

	EFormatTypeMask = __BT_BITMASK__(EFormatTypeLength)

	};

/** Push an object onto the cleanupstack.

@param aBTDeviceArray "The CBTDeviceArray object to be pushed onto the cleanupstack.

@leave This method will leave if an error occurs.

**/

EXPORT_C void BTDeviceArrayCleanupStack::PushL(CBTDeviceArray* aBTDeviceArray)

	{

	CleanupStack::PushL(TCleanupItem(&BTDeviceArrayCleanupStack::ResetAndDestroy, (TAny*)aBTDeviceArray));

	}

/** Method used by the cleanup stack to reset and destroy the array.

@param aBTDeviceArray "The array to be reset and destroyed"

**/

void BTDeviceArrayCleanupStack::ResetAndDestroy(TAny* aBTDeviceArray)

	{

	CBTDeviceArray* array = static_cast<CBTDeviceArray*>(aBTDeviceArray);

	array->ResetAndDestroy();

	delete array;

	}

/**

Convert a narrow TBTDeviceName8 to a wide TBTDeviceName.  Uses utf8->unicode conversion.

@param aName "The name to be converted"

@return "The converted name"

@leave "This method will leave if an error occurs with the utf8->unicode conversion"

**/

EXPORT_C TBTDeviceName BTDeviceNameConverter::ToUnicodeL(const TBTDeviceName8& aName)

	{

	TBTDeviceName ret;

	User::LeaveIfError(CnvUtfConverter::ConvertToUnicodeFromUtf8(ret, aName));

	return ret;

	}

/**

Convert a wide TBTDeviceName to a narrow TBTDeviceName8.  Uses unicode->utf8 conversion.

@param aName "The name to be converted"

@return "The converted name"

@leave "This method will leave if an error occurs with the unicode->utf8 conversion"

**/

EXPORT_C TBTDeviceName8 BTDeviceNameConverter::ToUTF8L(const TBTDeviceName& aName)

	{

	TBTDeviceName8 ret;

	User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(ret, aName));

	return ret;

	}

/**

Constructor.

Initialises the device class to 0.

**/

EXPORT_C TBTDeviceClass::TBTDeviceClass() :

	iDeviceClass(0), iPadding1(0), iPadding2(0)

	{

	}

/**

Constructor

@param	aDeviceClass The initial device class

**/

EXPORT_C TBTDeviceClass::TBTDeviceClass(TUint32 aDeviceClass) :

	iDeviceClass(aDeviceClass), iPadding1(0), iPadding2(0)

	{

	}

/** 

Constructor taking separate fields for combination into device class

Construct a Class of Device using format #1 as per the

<a href="https://www.bluetooth.org/foundry/assignnumb/document/baseband">baseband

assigned numbers</a>.

Note that this is a 24-bit field which we store in a 32-bit integer.

@param aMajorServiceClass The major service class for the device.

@param aMajorDeviceClass The major device class.

@param aMinorDevice The minor device class.

*/

EXPORT_C TBTDeviceClass::TBTDeviceClass(TUint16 aMajorServiceClass, TUint8 aMajorDeviceClass,

										TUint8 aMinorDeviceClass) :

	iDeviceClass(0), iPadding1(0), iPadding2(0)

	{

	iDeviceClass = (aMajorServiceClass & EMajorServiceMask);	// [00000000]0000000000000xxxxxxxxxxx

	iDeviceClass <<= EMajorDeviceLength;	// [00000000]00000000xxxxxxxxxxx00000

	iDeviceClass |= (aMajorDeviceClass & EMajorDeviceMask);	// [00000000]00000000xxxxxxxxxxxyyyyy

	iDeviceClass <<= EMinorDeviceLength;	// [00000000]00xxxxxxxxxxxyyyyy000000

	iDeviceClass |= (aMinorDeviceClass & EMinorDeviceMask);// [00000000]00xxxxxxxxxxxyyyyyzzzzzz

	iDeviceClass <<= EFormatTypeLength;	// [00000000]xxxxxxxxxxxyyyyyzzzzzz00

	}

/**

Getter for major service class

@return The MajorServerClass

Currently we only support CoD format #1.

*/

EXPORT_C TUint16 TBTDeviceClass::MajorServiceClass() const

	{

	if ((iDeviceClass & EFormatTypeMask) != 0x00)

		{

		return 0;

		}

	TUint32 servClass =	iDeviceClass >> (EMajorDeviceLength +

										 EMinorDeviceLength +

										 EFormatTypeLength);

	return static_cast<TUint16>(servClass & EMajorServiceMask);

	}

/**

Getter for major device class

@return The MajorDeviceClass

Currently we only support CoD format #1.

*/

EXPORT_C TUint8 TBTDeviceClass::MajorDeviceClass() const

	{

	if ((iDeviceClass & EFormatTypeMask) != 0x00)

		{

		return 0;

		}

	TUint32 majClass = iDeviceClass >> (EMinorDeviceLength + EFormatTypeLength);

	return static_cast<TUint8>(majClass & EMajorDeviceMask);

	}

/**	

Getter for minor device class

@return The MinorDeviceClass

Currently we only support CoD format #1.

*/

EXPORT_C TUint8 TBTDeviceClass::MinorDeviceClass() const

	{

	if ((iDeviceClass & EFormatTypeMask) != 0x00)

		{

		return 0;

		}

	TUint32 minClass = iDeviceClass >> (EFormatTypeLength);

	return static_cast<TUint8>(minClass & EMinorDeviceMask);

	}

/**

Getter for whole device class

@return The DeviceClass

*/

EXPORT_C TUint32 TBTDeviceClass::DeviceClass() const

	{

	return iDeviceClass;

	}

/**

Comparison operator

@param aDeviceClass the instance with which this is compared

@return ETrue if device classes are equal, otherwise false

*/

EXPORT_C TBool TBTDeviceClass::operator==(const TBTDeviceClass& aDeviceClass) const

	{

	TBool retval = (iDeviceClass==aDeviceClass.DeviceClass());

	return retval;

	}

/**

Assignment operator

@param aDeviceClass the instance from which this is assigned

@return this Device Class

*/

EXPORT_C TBTDeviceClass& TBTDeviceClass::operator=(const TBTDeviceClass& aDeviceClass)

	{

	if (this != &aDeviceClass)

		{

		iDeviceClass = aDeviceClass.DeviceClass();

		}

	return *this;

	}

/**

Extenalize this object to a stream.

@param aStream The stream object to which the class data will be written.

@leave This method will leave if an error occurs.

*/

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

	{

	aStream.WriteUint32L(KStreamVersion);

	aStream.WriteUint32L(iDeviceClass);

	}

/**

Internalize this object from a stream.

@param aStream The stream object containing the data with which to internalize this object.

@leave This method will leave if an error occurs.

*/

EXPORT_C void TBTDeviceClass::InternalizeL(RReadStream& aStream)

	{

	TUint32 version = aStream.ReadUint32L();

	static_cast<void>(version); // Currently only one valid version.

	iDeviceClass = aStream.ReadUint32L();

	}

//====================================================================

/**

Constructor.

*/

EXPORT_C TBTNamelessDevice::TBTNamelessDevice()

	: iSetMask(0)

	, iLinkKeyType(ELinkKeyCombination)

	{

	}

/**

Constructor.  Use NewL() or NewLC() to create an object of this type instead of this constructor.

*/

CBTDevice::CBTDevice()	

	{

	}

/**

Two-phase default constructor

Create an empty device.  The object will be placed on the cleanupstack and must be removed by the caller.

@return CBTDevice

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewLC()

	{

	CBTDevice* self = new(ELeave) CBTDevice();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

Two-phase default constructor

Create an empty device.

@return The new CBTDevice object.

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewL()

	{

	CBTDevice* self = CBTDevice::NewLC();

	CleanupStack::Pop();	//self

	return self;

	}

/**

Two-phase constructor

@param aBDAddr the address of the device to which this class refers

@return The new CBTDevice object.  The object will be left on the cleanupstack.

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewLC(const TBTDevAddr& aBDAddr)

	{

	CBTDevice* self = new(ELeave) CBTDevice;

	CleanupStack::PushL(self);

	self->ConstructL(aBDAddr);

	return self;

	}

/**

Two-phase constructor

Create a device and set its address.

@param aBDAddr the address of the device to which this class refers

@return The new CBTDevice object.

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewL(const TBTDevAddr& aBDAddr)

	{

	CBTDevice* self = CBTDevice::NewLC(aBDAddr);

	CleanupStack::Pop();	//self

	return self;

	}

/**

Two-phase copy constructor

Create a device based on the smaller nameless device

@param aNamelessDevice the device to copy

@return this Device

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewL(const TBTNamelessDevice& aNamelessDevice)

	{

	CBTDevice* self = CBTDevice::NewLC(aNamelessDevice);

	CleanupStack::Pop();	//self

	return self;

	}

/**

Two-phase copy constructor

Create a device based on the smaller nameless device

@param aNamelessDevice the device to copy

@return this Device, placed on the cleanupstack.

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::NewLC(const TBTNamelessDevice& aNamelessDevice)

	{

	CBTDevice* self = new(ELeave) CBTDevice();

	CleanupStack::PushL(self);

	self->ConstructL(aNamelessDevice);

	return self;

	}

void CBTDevice::ConstructL()

	{

	CommonConstructL();

	}

void CBTDevice::ConstructL(const TBTDevAddr& aDevAddr)

	{

	CommonConstructL();

	iDevice.SetAddress(aDevAddr);

	}

void CBTDevice::ConstructL(const TBTNamelessDevice& aNamelessDevice)

	{

	CommonConstructL();

	iDevice.Update(aNamelessDevice);

	}

void CBTDevice::CommonConstructL()

	{

	}

/**

Destructor.

*/

EXPORT_C CBTDevice::~CBTDevice()

	{

	delete iDeviceName;

	delete iFriendlyName;

	}

/**

Copies the contents of this into a new CBTDevice object.

@leave This method will leave if an error occurs.

*/

EXPORT_C CBTDevice* CBTDevice::CopyL() const

	{

	CBTDevice* newDevice = CBTDevice::NewLC();

	if (IsValidBDAddr())

		newDevice->SetDeviceAddress(BDAddr());

	if (IsValidDeviceName())

		newDevice->SetDeviceNameL(DeviceName());

	if (IsValidFriendlyName())

		newDevice->SetFriendlyNameL(FriendlyName());

	if (IsValidDeviceClass())

		newDevice->SetDeviceClass(DeviceClass());

	 if(IsValidLinkKey())

		newDevice->SetLinkKey(LinkKey(),LinkKeyType());

	if (IsValidGlobalSecurity())

		newDevice->SetGlobalSecurity(GlobalSecurity());

	if (iDevice.IsValidPageScanRepMode())

		newDevice->AsNamelessDevice().SetPageScanRepMode(iDevice.PageScanRepMode());

	if (iDevice.IsValidPageScanMode())

		newDevice->AsNamelessDevice().SetPageScanMode(iDevice.PageScanMode());

	if (iDevice.IsValidPageScanPeriodMode())

		newDevice->AsNamelessDevice().SetPageScanPeriodMode(iDevice.PageScanPeriodMode());

	if (iDevice.IsValidClockOffset())

		newDevice->AsNamelessDevice().SetClockOffset(iDevice.ClockOffset());

	if (IsValidSeen())

		newDevice->SetSeen(Seen());

	if (IsValidUsed())

		newDevice->SetUsed(Used());

	if (IsValidPassKey())

		newDevice->SetPassKey(PassKey());

	if (IsValidPaired())

		{

		if (!IsPaired())

			{

			newDevice->SetPaired(EFalse);

			}

		else if (!IsValidLinkKey())

			{

			newDevice->SetPaired(LinkKeyType()); // If link key is valid then "paired" status is already set.

			}

		}

	if (IsValidUiCookie())

		newDevice->SetUiCookie(UiCookie());

	CleanupStack::Pop(newDevice);

	return newDevice;

	}

/**

Update 'this' with valid details of aDevice, leaving already present settings

@param aDevice The device details to be used to update this device.

@publishedPartner

@released

*/

EXPORT_C void TBTNamelessDevice::Update(const TBTNamelessDevice& aDevice)

	{

	if (aDevice.IsValidAddress())

		SetAddress(aDevice.Address());

	if (aDevice.IsValidDeviceClass())

		SetDeviceClass(aDevice.DeviceClass());

	if (aDevice.IsValidLinkKey())

		SetLinkKey(aDevice.LinkKey(), aDevice.LinkKeyType());

	if (aDevice.IsValidGlobalSecurity())

		SetGlobalSecurity(aDevice.GlobalSecurity());

	if (aDevice.IsValidPageScanRepMode())

		SetPageScanRepMode(aDevice.PageScanRepMode());

	if (aDevice.IsValidPageScanMode())

		SetPageScanMode(aDevice.PageScanMode());

	if (aDevice.IsValidPageScanPeriodMode())

		SetPageScanPeriodMode(aDevice.PageScanPeriodMode());

	if (aDevice.IsValidClockOffset())

		SetClockOffset(aDevice.ClockOffset());

	if (aDevice.IsValidSeen())

		SetSeen(aDevice.Seen());

	if (aDevice.IsValidUsed())

		SetUsed(aDevice.Used());

	if (aDevice.IsValidPassKey())

		SetPassKey(aDevice.PassKey());

	if(aDevice.IsValidPaired())

		{		

		if (!aDevice.IsPaired())

			{

			SetPaired(EFalse);

			}

		else if (!aDevice.IsValidLinkKey())

			{

			SetPaired(aDevice.LinkKeyType()); // If link key is valid then "paired" status is already set.

			}		

		}

	if(aDevice.IsValidUiCookie())

		SetUiCookie(aDevice.UiCookie());

	}

/**

Compare the attributes of aDevice to *this and return a bitfield of matching attributes.

@see TBTDeviceSet

@publishedPartner

@released

@return bit field indicating what attributes of aDevice are equal to self

*/

EXPORT_C TUint TBTNamelessDevice::CompareTo(const TBTNamelessDevice& aDevice) const

	{

	TUint retval = EAllNamelessProperties;

	//Check that data is valid before comparing values:

	//if both valid, values must equate

	//if both invalid, treat as equal regardless of values

	if (!((IsValidAddress() && aDevice.IsValidAddress() && (Address()==aDevice.Address()))

		|| (!IsValidAddress() && !aDevice.IsValidAddress())))

		{

		retval &= ~EAddress;

		}

	if (!((IsValidDeviceClass() && aDevice.IsValidDeviceClass() && (DeviceClass()==aDevice.DeviceClass()))

		|| (!IsValidDeviceClass() && !aDevice.IsValidDeviceClass())))

		{

		retval &= ~EDeviceClass;

		}

	if (!((IsValidLinkKey() && aDevice.IsValidLinkKey() && (LinkKey()==aDevice.LinkKey()) && (LinkKeyType() == aDevice.LinkKeyType()))

		|| (!IsValidLinkKey() && !aDevice.IsValidLinkKey())))

		{

		retval &= ~ELinkKey;

		}

	if (!((IsValidPageScanRepMode() && aDevice.IsValidPageScanRepMode() 

		&& (PageScanRepMode()==aDevice.PageScanRepMode()))

		|| (!IsValidPageScanRepMode()  && !aDevice.IsValidPageScanRepMode())))

		{

		retval &= ~EPageScanRepMode;

		}

	if (!((IsValidPageScanMode() && aDevice.IsValidPageScanMode()

		&& (PageScanMode() == aDevice.PageScanMode()))

		|| (!IsValidPageScanMode()  && !aDevice.IsValidPageScanMode())))