/*
* Copyright (c) 2005-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 "T_BTDevAddrData.h"
#include "T_CBluetoothSocketData.h"


//Constant Literals used.

//Parameters
_LIT(KDevAddress,										"btdevaddress");
_LIT(KBTAddr,											"btaddr");
_LIT(KHexBTAddrL,										"hex_btaddr_l");
_LIT(KHexBTAddrR,										"hex_btaddr_r");
_LIT(KDeviceName,										"devicename");
_LIT(KBTSocket,											"btsocket");
_LIT(KUseLocalName,										"uselocalname");

//TBTDevAddr
_LIT(KCmdConstruct, 									"Construct");
_LIT(KCmdSetAddress, 									"SetBTAddr");

_LIT(KCmdOpenHostResolver,								"OpenHostResolver");
_LIT(KCmdSetHostNameL,									"SetHostNameL");
_LIT(KCmdSetDiscoverable,								"SetDiscoverable");
_LIT(KCmdGetDeviceAddress,								"GetDeviceAddress");
_LIT(KCmdDistructor,									"~");

/*@}*/

CT_BTDevAddrData* CT_BTDevAddrData::NewL()
	{
	CT_BTDevAddrData*	ret=new (ELeave) CT_BTDevAddrData();
	CleanupStack::PushL(ret);
	ret->ConstructL();
	CleanupStack::Pop(ret);
	return ret;
	}

CT_BTDevAddrData::CT_BTDevAddrData()
: iBTDevAddr(NULL),	iActive(NULL), iHostResolverOpen(EFalse)
	{
	}

void CT_BTDevAddrData::ConstructL()
	{
	iActive = CActiveCallback::NewL(*this);
	}

CT_BTDevAddrData::~CT_BTDevAddrData()
	{
	if( iHostResolverOpen )
		{
		iHostResolver.Close();
		}

	Cleanup();

	delete iActive;
	iActive = NULL;
	}

void CT_BTDevAddrData::Cleanup()
	{
	delete iBTDevAddr;
	iBTDevAddr=NULL;
	}

inline TCleanupOperation CT_BTDevAddrData::CleanupOperation()
	{
	return CleanupOperation;
	}

void CT_BTDevAddrData::CleanupOperation(TAny* aAny)
	{
	TBTDevAddr* arg=static_cast<TBTDevAddr*>(aAny);
	delete arg;
	}

TBool CT_BTDevAddrData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
	{
	TBool								retVal=ETrue;

	if ( aCommand==KCmdConstruct )
		{
		TBTDAConstruct(aSection);
		}
	else if ( aCommand==KCmdSetAddress )
		{
		TBTDASetAddress(aSection);
		}
	else if ( aCommand==KCmdSetHostNameL )
		{
		SetHostNameL(aSection);
		}
	else if ( aCommand==KCmdOpenHostResolver )
		{
		OpenHostResolver(aSection);
		}
	else if ( aCommand==KCmdSetDiscoverable )
		{
		SetDiscoverable(aSection);
		}
	else if ( aCommand==KCmdGetDeviceAddress )
		{
		GetDeviceAddress(aSection, aAsyncErrorIndex);
		}
	else if ( aCommand==KCmdDistructor )
		{				
		Cleanup();
		}	
	else
		{
		retVal=EFalse;
		}
	return retVal;
	}

void CT_BTDevAddrData::TBTDAConstruct(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TBTDevAddr Constructor Call"));
	TPtrC myDevAddrName;
	TBTDevAddr*	myDevAddr=NULL;
	if ( !GetStringFromConfig(aSection, KDevAddress(), myDevAddrName) )
		{
		//Use default constructor
		Cleanup();
		iBTDevAddr = new (ELeave) TBTDevAddr();
		}
	else
		{
		TRAPD( err, myDevAddr=static_cast<TBTDevAddr*>(GetDataObjectL(myDevAddrName)) );

		if ( (!err) && (myDevAddr!=NULL) )
			{
			Cleanup();
			TRAPD( err, iBTDevAddr = new (ELeave) TBTDevAddr(*myDevAddr) );
			SetError(err);
			}
		else
			{
			ERR_PRINTF2(_L("TBTDAConstructFromDevAddr TSockAddr is NULL and GetDataObjectL returned err = %d"), err);
			SetBlockResult(EFail);
			}
		}
	}


void CT_BTDevAddrData::TBTDASetAddress(const TDesC& aSection)
	{
	TInt	devId;
	if( GetIntFromConfig(aSection, KBTAddr(), devId))
		{
		INFO_PRINTF2(_L("Set TBTDevAddr (%d)"), devId);
		*iBTDevAddr = devId;
		}
	else
		{
		TPtrC		bluetoothSocketName;
		if( GetStringFromConfig(aSection, KBTSocket(), bluetoothSocketName))
			{
			CT_BluetoothSocketNotifier*	bluetoothSocketNotifier=static_cast<CT_BluetoothSocketNotifier*>(GetDataObjectL(bluetoothSocketName));
			if ( bluetoothSocketNotifier!=NULL )
				{
				TBool				useLocalName = ETrue;
				GetBoolFromConfig(aSection, KUseLocalName(), useLocalName);

				T_TBTSockAddrChild	addr;
				if( useLocalName )
					{
					bluetoothSocketNotifier->iBluetoothSocket->LocalName(addr);
					}
				else
					{
					bluetoothSocketNotifier->iBluetoothSocket->RemoteName(addr);
					}

				*iBTDevAddr = addr.BTAddr();
				TBuf<KMaxSockAddrSize>	tmpBuf;
				iBTDevAddr->GetReadable(tmpBuf);
				INFO_PRINTF2(_L("Set TBTDevAddr (%S)"), &tmpBuf);
				}
			else
				{
				ERR_PRINTF1(_L("CT_BluetoothSocketNotifier is NULL"));
				SetBlockResult(EFail);
				}
			}
		else
			{
			TInt	lhs;
			if ( !GetHexFromConfig(aSection, KHexBTAddrL(), lhs ))
				{
				ERR_PRINTF1(_L("TBTDevAddr GetHexFromConfig failed"));
				SetBlockResult(EFail);
				}

			TInt	rhs;
			if ( !GetHexFromConfig(aSection, KHexBTAddrR(), rhs ))
				{
				ERR_PRINTF1(_L("TBTDevAddr GetHexFromConfig failed"));
				SetBlockResult(EFail);
				}
			*iBTDevAddr = (MAKE_TINT64(lhs, rhs));
			}
		}
	}


void CT_BTDevAddrData::OpenHostResolver(const TDesC& aSection)
	{
	RSocketServ	sockServ;
	TPtrC		bluetoothSocketName;
	if( GetStringFromConfig(aSection, KBTSocket(), bluetoothSocketName))
		{
		CT_BluetoothSocketNotifier*	bluetoothSocketData=static_cast<CT_BluetoothSocketNotifier*>(GetDataObjectL(bluetoothSocketName));
		if ( bluetoothSocketData!=NULL )
			{
			sockServ = bluetoothSocketData->iSocketServer;
			}
		else
			{
			ERR_PRINTF1(_L("CT_CBluetoothSocketDataPersistentObject is NULL"));
			SetBlockResult(EFail);
			}
		}

	//	Find protocol from socket
	TProtocolDesc	protocolDesc;
	TInt			err=sockServ.FindProtocol(_L("BTLinkManager"), protocolDesc);
	if ( err!=KErrNone )
		{
		ERR_PRINTF2(_L("iSockServ.FindProtocol(aProtocolName, protocolDesc) = %d"), err);
        SetError(err);
		}
	if ( protocolDesc.iAddrFamily != KBTAddrFamily )
		{
		ERR_PRINTF1(_L("Wrong iAddrFamily"));
        SetBlockResult(EFail);
		}

	//	Open host resolver
	err=iHostResolver.Open(sockServ, protocolDesc.iAddrFamily, protocolDesc.iProtocol);
	if ( err!=KErrNone )
		{
		ERR_PRINTF2(_L("iHostResolver.Open(iSockServ, protocolDesc.iAddrFamily, protocolDesc.iProtocol) = %d"), err);
        SetError(err);
		}
	else
		{
		iHostResolverOpen = ETrue;
		}
	}

void CT_BTDevAddrData::SetHostNameL(const TDesC& aSection)
	{
	TPtrC deviceName;
	if( GetStringFromConfig(aSection, KDeviceName(), deviceName) )
		{
		TInt err=iHostResolver.SetHostName(deviceName);

		INFO_PRINTF2(_L("iHostResolver.SetHostName(%S)"), &deviceName);

		if( err!=KErrNone )
			{
			ERR_PRINTF2(_L("iHostResolver.SetHostName() = %d"), err);
			SetError(err);
			}
		}
	else
		{
		ERR_PRINTF1(_L("No HostName given"));
		SetBlockResult(EFail);
		}
	}

void CT_BTDevAddrData::SetDiscoverable(const TDesC& /*aSection*/)
	{
	TInt err = RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetLimitedDiscoverableStatus, EFalse);
	INFO_PRINTF1(_L("RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetLimitedDiscoverableStatus, EFalse) called"));
	if( err!=KErrNone )
		{
		ERR_PRINTF2(_L("RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetLimitedDiscoverableStatus, EFalse) = %d"), err);
		SetError(err);
		}

	err = RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus, EInquiryAndPageScan);
	INFO_PRINTF1(_L("RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus, EInquiryAndPageScan) called"));
	if( err!=KErrNone )
		{
		ERR_PRINTF2(_L("RProperty::Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus, EInquiryAndPageScan) = %d"), err);
		SetError(err);
		}
	}

void CT_BTDevAddrData::GetDeviceAddress(const TDesC& aSection, const TInt aIndex)
	{
	if( GetStringFromConfig(aSection, KDeviceName(), iDeviceName) )
		{
		// Set up the type of Bluetooth search we want to do
		iAddr.SetIAC(KGIAC);
		iAddr.SetAction(KHostResInquiry | KHostResName);

		// Make the asynchronous call to look for all devices
		iHostResolver.GetByAddress(iAddr, iBtNameEntry, iActive->iStatus);
		INFO_PRINTF1(_L("GetByAddress() called"));

		iActive->Activate(aIndex);
		IncOutstanding();
		}
	else
		{
		ERR_PRINTF1(_L("No device name given"));
		SetBlockResult(EFail);
		}
	}

const TBTDevAddr* CT_BTDevAddrData::GetAddress()
	{
	return iBTDevAddr;
	}

TAny* CT_BTDevAddrData::GetObject()
	{
	return iBTDevAddr;
	}

void CT_BTDevAddrData::SetObjectL(TAny* aObject)
	{
	delete iBTDevAddr;
	iBTDevAddr = static_cast<TBTDevAddr*>(aObject);
	}

void CT_BTDevAddrData::DisownObjectL()
	{
	iBTDevAddr=NULL;
	}

void CT_BTDevAddrData::CopyObjectL(TAny* aObjectPtr)
	{
	Cleanup();
	TBTDevAddr* tmp = static_cast<TBTDevAddr*>(aObjectPtr);
	iBTDevAddr =new (ELeave) TBTDevAddr(*tmp);
	}

/**
 Virtual RunL - Called on completion of an a Synchronous command
 @publishedInternal
 @see MT_MMActiveCallback
 @param aActive Active Object that RunL has been called on
 @pre N/A
 @post N/A
 @leave system wide error code
*/
void CT_BTDevAddrData::RunL(CActive* aActive, const TInt aIndex)
 	{
 	if ( aActive==iActive )
 		{
 		RunGetDeviceAddress(aIndex);
 		}
 	else
 		{
 		ERR_PRINTF1(_L("Stray signal"));
 		SetBlockResult(EFail);
 		}
 	}

/**
  Virtual DoCancel - Request to cancel the asynchronous command
  @publishedInternal
  @see - MTPActiveCallback
  @param aActive Active Object that DoCancel has been called on
  @pre - N/A
  @post - N/A
  @leave system wide error code
 */
 void CT_BTDevAddrData::DoCancel(CActive* aActive, const TInt /*aIndex*/)
 	{
 	if ( aActive!=iActive )
 		{
 		ERR_PRINTF1(_L("Stray signal"));
 		SetBlockResult(EFail);
 		}
 	}

/**
  RunCustomCommand - Process RunL for iActive
  @publishedInternal
  @pre N/A
  @post N/A
  @leave system wide error code
 */
 void CT_BTDevAddrData::RunGetDeviceAddress(const TInt aIndex)
	{
	TInt	err = iActive->iStatus.Int();
	if ( err == KErrNone )
		{
		THostName	deviceName = iBtNameEntry().iName;
		INFO_PRINTF2(_L("Device %S Found"), &deviceName);

		if( deviceName == iDeviceName )
			{
			INFO_PRINTF2(_L("Found required device %S"), &deviceName);

			TBTSockAddr	sockAddr(iBtNameEntry().iAddr);
			*iBTDevAddr = sockAddr.BTAddr();
			TBuf<KMaxSockAddrSize> tmpBuf;
			iBTDevAddr->GetReadable(tmpBuf);
			INFO_PRINTF2(_L("Set TBTDevAddr (%S)"), &tmpBuf);

         	DecOutstanding();
			}
		else
			{
			INFO_PRINTF1(_L("Still Searching..."));
			//Grab the details of the next device
			iHostResolver.Next(iBtNameEntry, iActive->iStatus);
			iActive->Activate(aIndex);
			}
		}
	else
		{
		ERR_PRINTF2(_L("RunL Error %d"), err);
		SetAsyncError(aIndex, err);
     	DecOutstanding();
		}
	}