// 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 <e32base.h>
#include <e32std.h>
#include "exchange.h"
#include "btexchange.h"


//Dll entry
EXPORT_C TInt _E32Dll()
	{
	return KErrNone;
	}

//Construction
/**
@internalComponent
Factory function that constructs a CBluetoothExchanger object.
@param aUUID
The Universally Unique IDentifier of the service that is provided
and should be searched for.
@return The constructed object
*/
EXPORT_C CBluetoothExchanger* CBluetoothExchanger::NewL(const TUUID &aUUID)
	{
	CBluetoothExchanger* self = CBluetoothExchanger::NewLC(aUUID);
	CleanupStack::Pop(self);
	return self;
	}

/**
@internalComponent
Factory function that constructs a CBluetoothExchanger object.
@param aUUID
The Universally Unique IDentifier of the service that is provided
and should be searched for.
@return The constructed object
*/
EXPORT_C CBluetoothExchanger* CBluetoothExchanger::NewLC(const TUUID &aUUID)
	{
	CBluetoothExchanger* self = new(ELeave) CBluetoothExchanger;
	CleanupStack::PushL(self);
	self->ConstructL(aUUID);
	return self;
	}

/**
@internalComponent
Initialises the class, and registers the service with the SDP database service.
@param aUUID
The Universally Unique IDentifier of the service that is provided
and should be searched for.
@leave If SDP registration fails, the function leaves.
*/
void CBluetoothExchanger::ConstructL(const TUUID &aUUID)
	{
	TSdpServRecordHandle recordHandle = 0;
	User::LeaveIfError(iSdpSession.Connect());
	User::LeaveIfError(iSdpDb.Open(iSdpSession));
	iSdpDb.CreateServiceRecordL(aUUID, recordHandle);
	//Service record with mandatory attributes now exists - maybe add others to it

	iSockSession.Connect();
	iSeeker = CBluetoothSeeker::NewL (iSockSession, aUUID);
	}

//Destruction
CBluetoothExchanger::~CBluetoothExchanger()
	{
	iSdpDb.Close();
	iSdpSession.Close();
	}

//Overrides of pure virtuals from CExchanger

//Inquiry & SDP implementation
/**
@internalComponent
Uses Inquiry and SDP to retrieve a list of peer devices which support
the UUID that was registered during construction.  
The functionality is implemented by the CBluetoothSeeker active object.
@param aStatus
A TRequestStatus object that is signalled when the search is complete.
@leave Leaves if the bluetooth protocols required can't be loaded.
*/
EXPORT_C void CBluetoothExchanger::LookForPeersL(TRequestStatus &aStatus)
	{
	//This is handled by the seeker class that we own.
	iSeeker->BeginUpdateL(aStatus);
	}

/**
@internalComponent
@return 
The count of devices that were found by the search.  
@pre 
A LookForPeersL search must have sucessfully completed
*/
EXPORT_C TInt CBluetoothExchanger::Count()
	{
	return iSeeker->Names().Count();
	}

/**
@internalComponent
Selects the first device that was found
*/
EXPORT_C void CBluetoothExchanger::First()
	{
	iDeviceIndex = 0;
	}

/**
@internalComponent
Retrieves the selected device, and selects the next device
that was found.
@param aPtr
A reference to a TNameEntry* pointer.  On success, it is filled
in with a pointer to a device that was found.  
@return KErrNotFound on failure, KErrNone on success.
*/
EXPORT_C TInt CBluetoothExchanger::Next(TNameEntry*& aPtr)
	{
	if(iDeviceIndex >= Count())
		return (KErrNotFound);
	aPtr = &(iSeeker->Names()[iDeviceIndex++]);
	return KErrNone;
	}

// CBluetoothSeeker 
_LIT(KBluetoothSeekerClassName, "CBluetoothSeeker");

// construction
CBluetoothSeeker::CBluetoothSeeker(RSocketServ &aSession) : CActive(CActive::EPriorityStandard), iSession(aSession), iNames(4)
	{
	iState = EIdle;
	}

CBluetoothSeeker::~CBluetoothSeeker()
	{
	iResolver.Close();
	delete iSdpAgent;
	delete iSdpSearchPattern;
	}

CBluetoothSeeker* CBluetoothSeeker::NewLC(RSocketServ &aSession, const TUUID &aUUID)
	{
	CBluetoothSeeker* self = new(ELeave) CBluetoothSeeker(aSession);
	CleanupStack::PushL(self);
	self->ConstructL(aUUID);
	return self;
	}

CBluetoothSeeker* CBluetoothSeeker::NewL(RSocketServ &aSession, const TUUID &aUUID)
	{
	CBluetoothSeeker* self = CBluetoothSeeker::NewLC(aSession, aUUID);
	CleanupStack::Pop(self);
	return self;
	}

void CBluetoothSeeker::ConstructL(const TUUID &aUUID)
	{
	iSdpSearchPattern = CSdpSearchPattern::NewL();
	iSdpSearchPattern->AddL(aUUID);
	CActiveScheduler::Add(this);
	}

void CBluetoothSeeker::RunL()
	{
	switch(iState)
		{
		case EInquiring:
			HandleInquiryResultL();
			break;
		case EServiceRequest:
			SDPQueryL();
			break;
		default:
			//RunL in bad state
			User::Panic(KBluetoothSeekerClassName, KErrGeneral);
			break;
		}
	}

TInt CBluetoothSeeker::RunError(TInt aErr)
	{
	//Complete any outstanding request with an error.
	if(iUpdateStatus)
		{
		User::RequestComplete(iUpdateStatus,aErr);
		}
	return KErrNone;
	}

void CBluetoothSeeker::DoCancel()
	{
	switch(iState)
		{
		case EInquiring:
			iResolver.Cancel();
			break;
		case EServiceRequest:
			delete iSdpAgent;
			iSdpAgent = NULL;
			break;
		default:
			break;
		}
	User::RequestComplete(iUpdateStatus, KErrCancel);
	}

void CBluetoothSeeker::BeginUpdateL(TRequestStatus &aStatus)
	{
	TProtocolDesc pInfo;
	_LIT(KLinkMan, "BTLinkManager");
	TProtocolName name(KLinkMan);
	User::LeaveIfError(iSession.FindProtocol(name,pInfo));
	if(IsActive())
		{
		User::Leave(KErrInUse);
		}
	//First, start an inquiry
	User::LeaveIfError(iResolver.Open(iSession,pInfo.iAddrFamily,pInfo.iProtocol));

	iInquiryAddress.SetIAC(KGIAC);
	iInquiryAddress.SetAction(KHostResInquiry);
	iResolver.GetByAddress(iInquiryAddress, iNameEntry, iStatus);
	SetActive();
	iState = EInquiring;
	iUpdateStatus = &aStatus;
	*iUpdateStatus = KRequestPending;
	}

CArrayFixFlat<TNameEntry>& CBluetoothSeeker::Names()
	{
	return iNames;
	}

void CBluetoothSeeker::HandleInquiryResultL()
	{
	if(iStatus.Int() == KErrNone)
		{
		//We found another device, add it to the list
		iNames.AppendL(iNameEntry);
		iResolver.Next(iNameEntry, iStatus);
		SetActive();
		}
	else if(iStatus.Int() == KErrHostResNoMoreResults)
		{
		//No more results, so now start SDP checks
		if(iNames.Count() == 0)
			{
			//No devices found by inquiry, so complete request now with a failure
			User::RequestComplete(iUpdateStatus, KErrNotFound);
			iState = EIdle;
			}
		else
			{
			//Some devices found, filter them by whether they support this service
			iDeviceIndex = 0;
			iState = EServiceRequest;
			SDPQueryL();
			}
		}
	else
		{
		//Some other error  - fail the request
		User::RequestComplete(iUpdateStatus, iStatus.Int());
		iState = EIdle;
		}
	}

void CBluetoothSeeker::SDPQueryL()
	{
	delete iSdpAgent;
	iSdpAgent = NULL;
	if(iDeviceIndex < iNames.Count())
		{
		TBTSockAddr* addr = (TBTSockAddr *)&((iNames[iDeviceIndex])().iAddr);
		iSdpAgent = CSdpAgent::NewL(*this, addr->BTAddr());
		iSdpAgent -> SetRecordFilterL(*iSdpSearchPattern);
		iSdpAgent -> NextRecordRequestL();
		// We signal ourselves when the callback completes
		iStatus = KRequestPending;
		SetActive();
		}
	else
		{
		//No more devices, set final status
		User::RequestComplete(iUpdateStatus, KErrNone);
		}
	}

//virtual overrides from MSdpAgentNotifier
void CBluetoothSeeker::NextRecordRequestComplete(TInt aError, TSdpServRecordHandle /*aHandle*/, TInt aTotalRecordsCount)
	{
	if(aError != KErrNone || aTotalRecordsCount == 0)
		{
		//This device doesnt support the service we are looking for
		//or SDP failed and we can't tell that it does.
		//Either way, remove it from our list of supported peers.
		iNames.Delete(iDeviceIndex);
		}
	else
		{
		//This device does support the service we are looking for
		//(Attribute requests would be done here if implemented)

		//While we are connected anyway (due to SDP), do a name request
		//- its almost free at this point, so use the synchronous version
		TInquirySockAddr &addr = TInquirySockAddr::Cast(iNames[iDeviceIndex]().iAddr);
		addr.SetAction(KHostResName);
		iResolver.GetByAddress(addr, iNames[iDeviceIndex]);
		//move on and check the next device.
		iDeviceIndex++;
		}
	//Signal ourself to process the next one
	TRequestStatus *status = &iStatus;
	User::RequestComplete(status,KErrNone);
	}

void CBluetoothSeeker::AttributeRequestResult(TSdpServRecordHandle , TSdpAttributeID , CSdpAttrValue* )
	{
	//should never be called (not currently used)
	User::Panic(KBluetoothSeekerClassName, KErrNotSupported);
	}
void CBluetoothSeeker::AttributeRequestComplete(TSdpServRecordHandle, TInt )
	{
	//should never be called (not currently used)
	User::Panic(KBluetoothSeekerClassName, KErrNotSupported);
	}