/*

* Copyright (c) 2004-2007 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:  Contains the CRsBtDevice class definition.

 *

*/

#include "crsbtdevice.h"

#include "clog.h"

#include "imageprint.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CRsBtDevice::CRsBtDevice()

	{

	}

CRsBtDevice::~CRsBtDevice()

	{

	LOG("CRsBtDevice::~CRsBtDevice begin");

	delete iPrinterModel;

	delete iDevice;

	iCapabilities.Close();

	LOG("CRsBtDevice::~CRsBtDevice end");

	}

CRsBtDevice* CRsBtDevice::NewL(const TNameRecord &aName)

	{

	CRsBtDevice* self = CRsBtDevice::NewLC(aName);

	CleanupStack::Pop(self);

	return self;

	}

CRsBtDevice* CRsBtDevice::NewL()

	{

	CRsBtDevice* self = CRsBtDevice::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CRsBtDevice* CRsBtDevice::NewLC(const TNameRecord &aName)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aName);

	return self;

	}

CRsBtDevice* CRsBtDevice::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CRsBtDevice* CRsBtDevice::NewLC(const CRsBtDevice &a)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(a);

	return self;

	}

CRsBtDevice* CRsBtDevice::NewL(const CRsBtDevice &a)

	{

	CRsBtDevice* self = CRsBtDevice::NewLC(a);

	CleanupStack::Pop(self);

	return self;

	}

void CRsBtDevice::ConstructL(const TNameRecord &aName)

	{

	LOG1("CRsBtDevice::ConstructL aName.iName: %S", &(aName.iName));

	TInquirySockAddr sockAddr = (TInquirySockAddr)aName.iAddr;

	TBTDeviceClass devClass(sockAddr.MajorServiceClass(),

			sockAddr.MajorClassOfDevice(),

			sockAddr.MinorClassOfDevice());

	iDevice = CBTDevice::NewL(sockAddr.BTAddr());

	iDevice->SetDeviceClass(devClass);

	iDevice->SetFriendlyNameL(aName.iName);

	Init();

	LOG("CRsBtDevice::ConstructL end");

	}

void CRsBtDevice::ConstructL()

	{

	iDevice = CBTDevice::NewL();

	Init();

	}

void CRsBtDevice::ConstructL(const CRsBtDevice &a)

	{

	iDevice = CBTDevice::NewL();

	if(a.iDevice)

		iDevice->UpdateL(*(a.iDevice));

	iBPPPort = a.iBPPPort;

	iSTSPort = a.iSTSPort;

	iOPPPort = a.iOPPPort;

	iSupportedProtocols = a.iSupportedProtocols;

	iVendor = a.iVendor;

	iJustFound = a.iJustFound;

	iTimeDiscovered = a.iTimeDiscovered;

	iTimeLastUsed = a.iTimeLastUsed;

	iUsed = a.iUsed;

	iPrinterModel = NULL;

	if(a.iPrinterModel)

		iPrinterModel = a.iPrinterModel->AllocL();

	iInternalDeviceId = a.iInternalDeviceId;

	iDisappeared = a.iDisappeared;

	iUsedProtocol = a.iUsedProtocol;

	iCapabilities.Reset();

	for(TInt i = 0; i < a.iCapabilities.Count(); ++i)

		{

		TPrintCapability capab;

		capab.iCapabilityID = a.iCapabilities[i].iCapabilityID;

		capab.iType = a.iCapabilities[i].iType;

		capab.iLow = a.iCapabilities[i].iLow;

		capab.iHigh = a.iCapabilities[i].iHigh;

		capab.iDefaultValue = a.iCapabilities[i].iDefaultValue;

		capab.iEnumCount = a.iCapabilities[i].iEnumCount;

		for(TInt j = 0; j < a.iCapabilities[i].iEnumCount; ++j)

			{

			capab.iEnumCodes[j] = a.iCapabilities[i].iEnumCodes[j];

			}

		AddCapability(capab);

		}

	}

void CRsBtDevice::Init()

	{

	iBPPPort = 0;

	iSTSPort = 0;

	iOPPPort = 0;

	iSupportedProtocols = 0;

	iVendor = TPrinter::EVendorNone;

	iJustFound = EFalse;

	iTimeDiscovered.UniversalTime();

	iTimeLastUsed.UniversalTime();

	iPrinterModel = NULL;

	iInternalDeviceId = KErrNotFound;

	iDisappeared = ETrue;

	iUsedProtocol = 0;

	iCapabilities.Reset();

	iUsed = EFalse;

	}

/**

 * Standard method to allow object to be streamed out to a file.

 * @param aStream Stream that object will be written to, should have already been opened.

 */

void CRsBtDevice::ExternalizeL(RWriteStream& aStream) const

	{

	LOG("[CRsBtDevice::ExternalizeL]\t Begin");

	aStream.WriteInt32L(iInternalDeviceId);

	aStream.WriteUint32L(iBPPPort);

	aStream.WriteUint32L(iSTSPort);

	aStream.WriteUint32L(iOPPPort);

	aStream.WriteInt32L(iSupportedProtocols);

	aStream.WriteUint32L(Vendor());

	TUint32 temp = iTimeLastUsed.Int64();

	aStream.WriteUint32L( temp );

	temp = iTimeLastUsed.Int64() >> 32;

	aStream.WriteUint32L( temp );

	temp = iTimeDiscovered.Int64();

	aStream.WriteUint32L( temp );

	temp = iTimeDiscovered.Int64() >> 32;

	aStream.WriteUint32L( temp );

	aStream.WriteInt32L(iPrinterModel->Des().MaxLength());

	aStream << *iPrinterModel;

	ExternalizeCapabilitiesL(aStream);

	aStream << *iDevice;

	LOG("[CRsBtDevice::ExternalizeL]\t end");

	}

void CRsBtDevice::ExternalizeCapabilitiesL(RWriteStream& aStream) const

	{

	LOG("CRsBtDevice::ExternalizeCapabilitiesL begin");

	aStream.WriteInt32L(iCapabilities.Count());

	for(TInt i = 0; i < iCapabilities.Count(); ++i)

		{

		aStream.WriteInt32L(iCapabilities[i].iCapabilityID);

		aStream.WriteInt32L(iCapabilities[i].iType);

		aStream.WriteInt32L(iCapabilities[i].iDefaultValue);

		aStream.WriteInt32L(iCapabilities[i].iLow);

		aStream.WriteInt32L(iCapabilities[i].iHigh);

		aStream.WriteInt32L(iCapabilities[i].iEnumCount);

		for(TInt j = 0; j < KMaxEnumAmount; ++j)

			{

			aStream.WriteInt32L(iCapabilities[i].iEnumCodes[j]);

			}

		}

	}

/**

 * Standard method to allow object to be streamed in from a file.

 * @param aStream Stream that object will be read from, should have already been opened.

 */

void CRsBtDevice::InternalizeL(RReadStream& aStream)

	{

	LOG("[CRsBtDevice::InternalizeL]\t Begin");

	TUint timeLastHigh, timeLastLow, timeDiscHigh, timeDiscLow;

	TInt maxlen;

	iInternalDeviceId = aStream.ReadInt32L();

	iBPPPort = aStream.ReadUint32L();

	iSTSPort = aStream.ReadUint32L();

	iOPPPort = aStream.ReadUint32L();

	iSupportedProtocols = aStream.ReadInt32L();

	SetVendor(static_cast<TPrinter::TPrinterVendor>( aStream.ReadUint32L() ));

	timeLastLow = aStream.ReadUint32L();

	timeLastHigh = aStream.ReadUint32L();

	timeDiscLow = aStream.ReadUint32L();

	timeDiscHigh = aStream.ReadUint32L();

	TInt64 temp;

	temp = timeLastHigh;

	temp = temp << 32;

	iTimeLastUsed = temp | timeLastLow;

	temp = timeDiscHigh;

	temp = temp << 32;

	iTimeDiscovered = temp | timeDiscLow;

	delete iPrinterModel;

	iPrinterModel = NULL;

	maxlen = aStream.ReadInt32L();

	iPrinterModel = HBufC::NewL(aStream,maxlen);

	InternalizeCapabilitiesL(aStream);

	iDevice->InternalizeL(aStream);

	iUsed = ETrue;

	LOG1("[CRsBtDevice::InternalizeL]\t End for: %S", &FriendlyName());

	}

void CRsBtDevice::InternalizeCapabilitiesL(RReadStream& aStream)

	{

	LOG("[CRsBtDevice::InternalizeCapabilitiesL]\t begin");

	iCapabilities.Reset();

	TInt count = aStream.ReadInt32L();

	for(TInt i = 0; i < count; ++i)

		{

		TPrintCapability capability;

		capability.iCapabilityID = aStream.ReadInt32L();

		capability.iType = (TPrintCapability::ECapType)aStream.ReadInt32L();

		capability.iDefaultValue = aStream.ReadInt32L();

		capability.iLow = aStream.ReadInt32L();

		capability.iHigh = aStream.ReadInt32L();

		capability.iEnumCount = aStream.ReadInt32L();

		for(TInt j = 0; j < KMaxEnumAmount; ++j)

			{

			capability.iEnumCodes[j] = aStream.ReadInt32L();

			}

		iCapabilities.Append(capability);

		}

	}

/**

 * Create a copy of the current object.

 * \returns A pointer to the new object, the caller takes ownership of the object.

 */

CRsBtDevice* CRsBtDevice::CopyL()

	{

	CRsBtDevice* newDevice = NewLC();

	newDevice->UpdateAllL(*this);

	CleanupStack::Pop(); // newDevice

	return newDevice;

	}

/**

 * Create a copy of the current object.

 * \returns A pointer to the new object, the caller takes ownership of the object.

 */

CRsBtDevice* CRsBtDevice::CopyL(CRsBtDevice& aSource)

	{

	CRsBtDevice* newDevice = NewLC();

	newDevice->UpdateAllL(aSource);

	CleanupStack::Pop(); // newDevice

	return newDevice;

	}

/**

 * \returns Address of descriptor containing the Bluetooth friendly name of the device.

 */

const TDesC& CRsBtDevice::FriendlyName() const

	{

	return iDevice->FriendlyName();

	}

/**

 * Stores the BPP port (channel).

 * @param aPort BPP port (channel) as unsigned integer. If CRsBtDevice::SetBPPPort is not called, initialized as 0.

 */

void CRsBtDevice::SetBPPPort(TUint aPort)

	{

	iBPPPort = aPort;

	}

/**

 * Stores the status port (channel).

 * @param aPort Status port (channel) as unsigned integer. If CRsBtDevice::SetSTSPort is not called, initialized as 0.

 */

void CRsBtDevice::SetSTSPort(TUint aPort)

	{

	iSTSPort = aPort;

	}

/**

 * Stores the OPP port (channel).

 * @param aPort OPP port (channel) as unsigned integer. If CRsBtDevice::SetOPPPort is not called, initialized as 0.

 */

void CRsBtDevice::SetOPPPort(TUint aPort)

	{

	iOPPPort = aPort;

	}

/**

 * Stores the protocols that this device support.

 * @param aSupportedProtocols The Supported Protocols by this device

 */

void CRsBtDevice::SetSupportedProtocols(TUint aSupportedProtocols)

	{

	iSupportedProtocols = aSupportedProtocols;

	}

/**

 * Obtain the supported protocols by this device

 * \returns The supported protocols by this device TUint @sa KImagePrint_PrinterProtocol_BPP @sa KImagePrint_PrinterProtocol_OPP_Printer @sa KImagePrint_PrinterProtocol_OPP_PC

 */

TUint CRsBtDevice::SupportedProtocols() const

	{

	return iSupportedProtocols;

	}

/**

 * Compares the Bluetooth device address of this Bluetooth device to the address of the passed in device.

 * @param aDevice Bluetooth device to compare this object to.

 * \returns True, Bluetooth device addresses are identical, False, Bluetooth device addresses as not identical.

 */

TBool CRsBtDevice::Equals( const CRsBtDevice &aDevice ) const

	{

	return (aDevice.iDevice->BDAddr() == iDevice->BDAddr());

	}

/**

 * \returns Bluetooth device address.

 */

const TBTDevAddr& CRsBtDevice::BDAddr() const

	{

	return iDevice->BDAddr();

	}

/**

 * \returns BPP port (channel) as an unsigned integer. If CRsBtDevice::SetBPPPort is not called, initialized as 0.

 */

TUint CRsBtDevice::BPPPort() const

	{

	return iBPPPort;

	}

/**

 * \returns status port (channel) as an unsigned integer. If CRsBtDevice::SetSTSPort is not called, initialized as 0.

 */

TUint CRsBtDevice::STSPort() const

	{

	return iSTSPort;

	}

/**

 * \returns OPP port (channel) as an unsigned integer. If CRsBtDevice::SetOPPPort is not called, initialized as 0.

 */

TUint CRsBtDevice::OPPPort() const

	{

	return iOPPPort;

	}

void CRsBtDevice::SetDisappeared(TBool aDisappeared)

	{

	iDisappeared = aDisappeared;

	}

TBool CRsBtDevice::IsDisappeared() const

	{

	return iDisappeared;

	}

/**

 * First calls CRsBtDevice::UpdateDeviceAndBPP, then updates any remaining data from the current device,

 * includes whether device is saved in the device cache, the number of prints, and time stamps of

 * discovery and when last used.

 * @param aDevice Device whose data will be used to update current device.

 * \returns True, data of the current device was updated, False, nothing changed.

 */

TBool CRsBtDevice::UpdateAllL(CRsBtDevice &aDevice)

	{

	TBool modified = EFalse;

	modified = UpdateDeviceAndBPPL(aDevice);

	if (iTimeDiscovered != aDevice.iTimeDiscovered)

		{

		iTimeDiscovered = aDevice.iTimeDiscovered;

		modified = ETrue;

		}

	if (iTimeLastUsed != aDevice.iTimeLastUsed)

		{

		iTimeLastUsed = aDevice.iTimeLastUsed;

		modified = ETrue;

		}

	return modified;

	}

/**

 * First calls CRsBtDevice::UpdateDevice, then updates the current devices BPP/OPP data,

 * includes BPP/OPP supported information and BPP/OPP port.

 * @param aDevice Device whose data will be used to update current device.

 * \returns True, data of the current device was updated, False, nothing changed.

 */

TBool CRsBtDevice::UpdateDeviceAndBPPL(CRsBtDevice &aDevice)

	{

	TBool modified = EFalse;

	modified = UpdateDeviceL(aDevice);

	if ((iSupportedProtocols & aDevice.SupportedProtocols()) != iSupportedProtocols)

		{

		iSupportedProtocols = aDevice.SupportedProtocols();

		modified = ETrue;

		}

	if (iBPPPort != aDevice.BPPPort())

		{

		iBPPPort = aDevice.BPPPort();

		modified = ETrue;

		}

	if (iSTSPort != aDevice.STSPort())

		{

		iSTSPort = aDevice.STSPort();

		modified = ETrue;

		}

	if (iOPPPort != aDevice.OPPPort())

		{

		iOPPPort = aDevice.OPPPort();

		modified = ETrue;

		}

	return modified;

	}

/**

 * Update the current devices Bluetooth device data, includes device address, friendly name and device class.

 * @param aDevice Device whose data will be used to update current device.

 * \returns True, data of the current device was updated, False, nothing changed.

 */

TBool CRsBtDevice::UpdateDeviceL(CRsBtDevice &aDevice)

	{

	TBool modified = EFalse;

	if( iDevice->BDAddr() != aDevice.iDevice->BDAddr() ||

			iDevice->FriendlyName() != aDevice.iDevice->FriendlyName() ||

			! (DeviceClass() == aDevice.DeviceClass()) )

		{

		iDevice->UpdateL(*(aDevice.iDevice));

		modified = ETrue;

		}

	if( iPrinterModel )

		{

		delete iPrinterModel;

		iPrinterModel = NULL;

		modified = ETrue;

		}

	if( aDevice.iPrinterModel )

		{

		iPrinterModel = aDevice.iPrinterModel->AllocL();

		modified = ETrue;

		}

	if( Vendor() != aDevice.Vendor() )

		{