/*

* 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 CBtDiscover class definition. Bluetooth device discovery and SDP.

*

*/

#include "cbtdiscover.h"

#include "clog.h"

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

// Construction/Destruction

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

/**

 * @brief Instantiate new CBtDiscover object.

 */

CBtDiscover* CBtDiscover::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

/**

 * @brief Two phase construction.

 */

void CBtDiscover::ConstructL()

	{

	iSdpSearchPattern = CSdpSearchPattern::NewL();

	iMatchList = CSdpAttrIdMatchList::NewL();

	}

/**

 * @brief Constructor.

 */

CBtDiscover::CBtDiscover() :

	iCurrentSDPAttrID(0),

	iCurrentServiceUUID(0),

	iFoundSTS(EFalse),

	iWantedService(ETrue),

	iDoingSDP(EFalse),

	iFindingDevices(EFalse),

	iAgent(NULL),

	iRequestStatus(NULL),

	iSdpSearchPattern(NULL),

	iMatchList(NULL),

	iContentTypes(NULL),

	iPrinterModel(NULL),

	iBPPPort(0),

	iSTSPort(0),

	iOPPPort(0)

	{

	}

/**

 * @brief Destructor.

 */

CBtDiscover::~CBtDiscover()

	{

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

	Stop();

	if(iSdpSearchPattern)

		delete iSdpSearchPattern;

	if(iMatchList)

		delete iMatchList;

	if(iContentTypes)

		delete iContentTypes;

	if(iPrinterModel)

		delete iPrinterModel;

	if(iAgent)

		delete iAgent;

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

	}

/**

 * @brief Destructor.

 */

void CBtDiscover::Reset()

	{

	LOG("CBtDiscover::Reset begin");

	StopSDP(); // resets also public member variables and iDoingSDP flag

	iBPPPort = 0;

	iSTSPort = 0;

	iOPPPort = 0;

	if(iPrinterModel)

		delete iPrinterModel;

	iPrinterModel = NULL;

	if(iSdpSearchPattern)

		iSdpSearchPattern->Reset();

	// No can do if remove fails -> ignore leave

	if(iMatchList)

		TRAP_IGNORE( iMatchList->RemoveL(TAttrRange(0x0000, 0xFFFF)) );

	if(iContentTypes)

		delete iContentTypes;

	iContentTypes = NULL;

	if( iRequestStatus )

	{

		if(KRequestPending == iRequestStatus->Int())

			User::RequestComplete(iRequestStatus, KErrNone);

	}

	iRequestStatus = NULL;

	LOG("CBtDiscover::Reset end");

	}

/**

  * @brief Starts the asynchronous search for Bluetooth devices.

  *

  * Starts the asynchronous search for Bluetooth devices. The Active Object containing

  * this object, CRsBtDiscoverEngine, is notified after the first device is found.

  * @param aStatus Status variable from CRsBtDiscoverEngine, receives notification when asynchronous call completes.

  */

void CBtDiscover::Start(TRequestStatus &aStatus)

	{

	LOG("[CBtDiscover::Start]\t begin");

	aStatus = KErrNotSupported;

	TInt err = iSocketServ.Connect();

	LOG1("[CBtDiscover::Start]\t iSocketServ.Connect() err: %d", err);

	if( KErrNone == err )

	{

		err = iHostResolver.Open( iSocketServ, KBTAddrFamily, KBTLinkManager );

		LOG1("[CBtDiscover::Start]\t iHostResolver.Open() err: %d", err);

	}

	if( KErrNone == err )

	{

		iFindingDevices = ETrue;

		iSockAddr.SetIAC( KGIAC );

		iSockAddr.SetAction( KHostResInquiry | KHostResName | KHostResIgnoreCache );

		iHostResolver.GetByAddress( iSockAddr, iNameEntry, aStatus );

	}

	else

	{

		iFindingDevices = EFalse;

		iSocketServ.Close();

		iHostResolver.Close();

	}

	LOG("[CBtDiscover::Start]\t end");

	}

/**

  * @brief Continues the asynchronous search for Bluetooth devices.

  *

  * Continues the asynchronous search for Bluetooth devices. The Active Object containing

  * this object, CRsBtDiscoverEngine, is notified after the next device is found.

  * @param aStatus Status variable from CRsBtDiscoverEngine, receives notification when asynchronous call completes.

  */

void CBtDiscover::GetNextDevice(TRequestStatus &aStatus)

	{

	LOG("[CBtDiscover::GetNextDevice]\t");

	iHostResolver.Next(iNameEntry, aStatus);

	}

/**

  * @brief Stop the asynchronous search for Bluetooth devices.

  */

void CBtDiscover::Stop()

	{

	LOG1("[CBtDiscover::Stop]\t begin with iFindingDevices: %d", iFindingDevices);

	if(iFindingDevices)

		iHostResolver.Cancel();

	iFindingDevices = EFalse;

	Reset();

	iHostResolver.Close();

	iSocketServ.Close();

	LOG("[CBtDiscover::Stop]\t end");

	}

/**

  * @brief Is an asynchronous search for Bluetooth devices in progress?

  * @return True, a search is in progress, or False, no search is in progress

  */

TBool CBtDiscover::IsFindingDevices() const

	{

	return iFindingDevices;

	}

/**

  * @brief Get the last Bluetooth device found by the search.

  * @return The last Bluetooth device found by the search.

  */

TNameRecord CBtDiscover::GetNameRecord() const

	{

	return iNameEntry();

	}

/**

  * @brief Store Bluetooth device information, in preparation for doing an SDP query.

  */

void CBtDiscover::SetNameRecord(TNameRecord aNameRecord)

	{

	TNameEntry nameEntry(aNameRecord);

	iNameEntry = nameEntry;

	}

/**

  * @brief Starts the asynchronous request for the SDP record.

  *

  * Starts the asynchronous request for the SDP record from a Bluetooth device.

  * Specifically the device is tested for the BPP and OPP services.

  * @param aStatus Status variable from CRsBtDiscoverEngine, receives notification when asynchronous call completes.

  * @param aServiceMask Bitmask to require (only) certain services. All marked by default.

  */

void CBtDiscover::GetSupportedServicesL(TRequestStatus &aStatus, TUint32 aServiceMask)

	{

	LOG("[CBtDiscover::GetSupportedServicesL]\t begin");

	Reset();

	iRequestStatus = &aStatus;

	*iRequestStatus = KRequestPending;	

	iMatchList->RemoveL(TAttrRange(0x0000, 0xFFFF));

	iMatchList->AddL(TAttrRange(KSdpAttrIdServiceClassIDList));

	iMatchList->AddL(TAttrRange(KSdpAttrIdProtocolDescriptorList));

	iMatchList->AddL(TAttrRange(KSdpAttrIdAdditionalProtocolDescriptorLists));

	iMatchList->AddL(TAttrRange(KSdpAttrIdDocFormatsSupported));

	iMatchList->AddL(TAttrRange(KSdpAttrIdModelID));

	iMatchList->AddL(TAttrRange(KSdpAttrIdMaxWidth));

	iMatchList->AddL(TAttrRange(KSdpAttrIdMaxLen));

	iSdpSearchPattern->Reset();

	if(KBtMaskObjectPush & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPOBEXObjectPush); // 0x1105

	if(KBtMaskDirectPrinting & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPDirectPrinting); // 0x1118

	if(KBtMaskPrintingStatus & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPPrintingStatus); // 0x1123

	if(KBtMaskL2CAP & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPL2CAP);

	if(KBtMaskRFCOMM & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPRFCOMM);

	if(KBtMaskObex & aServiceMask)

		iSdpSearchPattern->AddL(KBTSDPObex);

	StartSDPL();

	LOG("[CBtDiscover::GetSupportedServicesL]\t end");

	}

/**

  * @brief Initiate the SDP request started in VerifyServiceSupportL.

  */

void CBtDiscover::StartSDPL()

	{

	StopSDP();

	TBTDevAddr btAddr = ((TInquirySockAddr)iNameEntry().iAddr).BTAddr();

	iAgent = CSdpAgent::NewL(*this, btAddr);

	iAgent->SetRecordFilterL(*iSdpSearchPattern);

	iAgent->SetAttributePredictorListL(*iMatchList);

	iAgent->NextRecordRequestL();

	iDoingSDP = ETrue;

	}

/**

  * @brief Stop the asynchronous request for the SDP record from a Bluetooth device.

  */

void CBtDiscover::StopSDP()

	{

	LOG1("[CBtDiscover::StopSDP] begin with iAgent address: %d", TInt(iAgent));

	iDoingSDP = EFalse;

	iCurrentSDPAttrID = 0;

    iCurrentServiceUUID = 0;

	iFoundSTS = EFalse;

	iWantedService = ETrue;

	if( iAgent )

		{

		iAgent->Cancel();

		delete iAgent;

		iAgent = NULL;

		}

	LOG("[CBtDiscover::StopSDP] end");

	}

/**

  * @brief Is an asynchronous request for the SDP record in progress?.

  *

  * Is an asynchronous request for the SDP record from a Bluetooth device in progress?

  * @return True, a request is in progress, or False, no request is in progress

  */

TBool CBtDiscover::IsDoingSDP() const

	{

	return iDoingSDP;

	}

/**

  * The CSdpAgent object calls this to notify that the attributes from an SDP record are ready for parsing.

  * @param aAttrValue Structured attribute(s) of SDP record, parsed with TBTAttribValVisitor

  */

void CBtDiscover::AttributeRequestResult(TSdpServRecordHandle /*aHandle*/, TSdpAttributeID aAttrID, CSdpAttrValue *aAttrValue)

	{

	TRAPD( err, AttributeRequestResultL( aAttrID, aAttrValue ) );

	if(KErrNone != err)

		LOG1("[CBtDiscover::AttributeRequestResult]\t AttributeRequestResultL leaves with: %d", err);

	}

void CBtDiscover::AttributeRequestResultL( TSdpAttributeID aAttrID, CSdpAttrValue* aValue )

	{

	LOG1("[CBtDiscover::AttributeRequestResultL]\t *** Device: %S: ", &GetDeviceName() );

	LOG2("CBtDiscover::AttributeRequestResultL aAttrID: %d, aValue->Type(): %d", aAttrID, aValue->Type());

	iCurrentSDPAttrID = aAttrID;

	CBTAttribValVisitor* valVisitor = NULL;

	switch( aAttrID )

		{

		case KSdpAttrIdServiceClassIDList:

			iCurrentServiceUUID = 0; // reset

		case KSdpAttrIdProtocolDescriptorList:

		case KSdpAttrIdAdditionalProtocolDescriptorLists:

		case KSdpAttrIdDocFormatsSupported:

		case KSdpAttrIdModelID:

		case KSdpAttrIdMaxWidth:

		case KSdpAttrIdMaxLen:

			valVisitor = CBTAttribValVisitor::NewLC( *this );

			aValue->AcceptVisitorL( *valVisitor ); // goes in CBTAttribValVisitor::VisitAttributeValueL 

			CleanupStack::PopAndDestroy( valVisitor );

			break;

		default:

			break;

		}

	delete aValue;

	LOG("CBtDiscover::AttributeRequestResultL end");

	}

/**

  * The CSdpAgent object calls this to notify that the SDP record request has been completed.

  */

void CBtDiscover::NextRecordRequestComplete(TInt aError, TSdpServRecordHandle aHandle, TInt aTotalRecordsCount)

	{

	LOG1("CBtDiscover::NextRecordRequestComplete aError: %d", aError);

	LOG1("CBtDiscover::NextRecordRequestComplete aHandle: %d", aHandle);

	LOG1("CBtDiscover::NextRecordRequestComplete aTotalRecordsCount: %d", aTotalRecordsCount);

	TInt err( aError );

	if( KErrNone == aError  && aTotalRecordsCount > 0)

	{

		TRAP( err, iAgent->AttributeRequestL( aHandle, KSdpAttrIdServiceClassIDList ) );

		LOG1("CBtDiscover::NextRecordRequestComplete err: %d", err);

	}

	if( KErrNone != err || !aTotalRecordsCount )

	{

		if( KErrEof == err || !aTotalRecordsCount )

		{

			err = KErrNone;

		}

		StopSDP();

		LOG("CBtDiscover::NextRecordRequestComplete User::RequestComplete");

		User::RequestComplete( iRequestStatus, err );	

	}

	// reset

	iCurrentServiceUUID = 0; 

	iWantedService = ETrue;

	iCurrentSDPAttrID = 0;

	LOG("CBtDiscover::NextRecordRequestComplete end");

	}

/**

  * The CSdpAgent object calls this to notify that the current SDP record has no more attributes.

  * @param aError Standard Symbian error code, KErrNone indicates success.

  */

void CBtDiscover::AttributeRequestComplete(TSdpServRecordHandle aHandle, TInt aError)

{

	LOG("[CBtDiscover::AttributeRequestComplete]\t Begin.");

	if( KErrNone != aError || !iWantedService || 0 == iCurrentSDPAttrID)

	{

		LOG1("[CBtDiscover::AttributeRequestComplete]\t err: %d", aError);

		iCurrentSDPAttrID = 0;

		LOG("[CBtDiscover::AttributeRequestComplete]\t Not wanted service. Get next record.");

		TRAPD( err, iAgent->NextRecordRequestL() );

		if(KErrNone != err)

		{

			NextRecordRequestComplete(err, aHandle, 0);

		}

	}

	else

	{

		LOG("[CBtDiscover::AttributeRequestComplete]\t Wanted service. Get next attribute.");

		TRAPD( err, GetNextAttributeL(aHandle) );

		if( KErrNone != err )

			LOG1("[CBtDiscover::AttributeRequestComplete]\t err: %d", err);

	}

	iCurrentSDPAttrID = 0;

	LOG("[CBtDiscover::AttributeRequestComplete]\t End.");

}

/**

  * @brief Get BPP port.

  * @return Port (i.e. Bluetooth channel) of the BPP service on the printer. Returns -1 if port is unknown.

  */

TInt CBtDiscover::GetBPPPort() const

	{

	return iBPPPort;

	}

/**

  * @brief Get Status port.

  * @return Port (i.e. Bluetooth channel) of the status service on the printer. Returns -1 if port is unknown.

  */

TInt CBtDiscover::GetSTSPort() const

	{

	return iSTSPort;

	}

/**

  * @brief Get OPP port.

  * @return Port (i.e. Bluetooth channel) of the OPP service on the printer. Returns -1 if port is unknown.

  */

TInt CBtDiscover::GetOPPPort() const

	{

	return iOPPPort;

	}

/**

  * @brief Set the BPP Port.

  *

  * Called from TBTAttribValVisitor to set the Port (i.e. Bluetooth channel).

  * Also used to indicate that the BPP service was successfully detected in the SDP response.

  */

void CBtDiscover::SetBPPPort(TInt aPort)

	{

	LOG1("CBtDiscover::SetBPPPort aPort: %d", aPort);

	iBPPPort = aPort;

	}

/**

  * @brief Set the Status Port.

  *

  * Called from TBTAttribValVisitor to set the Port (i.e. Bluetooth channel).

  * Also used to indicate that the Status service was successfully detected in the SDP response.

  */

void CBtDiscover::SetSTSPort(TInt aPort)

	{

	LOG1("CBtDiscover::SetSTSPort aPort: %d", aPort);

	iSTSPort = aPort;

	}

/**

  * @brief Set the OPP Port.

  *

  * Called from TBTAttribValVisitor to set the Port (i.e. Bluetooth channel).

  * Also used to indicate that the OPP service was successfully detected in the SDP response.

  */

void CBtDiscover::SetOPPPort(TInt aPort)

	{

	LOG1("CBtDiscover::SetOPPPort aPort: %d", aPort);

	iOPPPort = aPort;

	}

/**

  * @brief Bluetooth device supports BPP?.

  *

  * Does the SDP response for the current Bluetooth device indicate that BPP is supported?

  * Checks to make sure that a Port (i.e. Bluetooth channel) for the BPP service was determined,

  * AND that the device supports the Mime/Multiplex document type.

  * @return True, BPP is supported, or False, BPP is not supported

  */

TBool CBtDiscover::IsBPPSupported() const

	{

	_LIT(KMimeXhtmlType, "application/vnd.pwg-xhtml-print+xml");

	_LIT(KMimeMultiplexType, "application/vnd.pwg-multiplexed");

	LOG1("CBtDiscover::IsBPPSupported iBPPPort: %d", iBPPPort);

	return ( iBPPPort && (SupportsContentType( KMimeMultiplexType ) || SupportsContentType( KMimeXhtmlType )) );

	}

/**

  * @brief Bluetooth device supports OPP?.

  *

  * Does the SDP response for the current Bluetooth device indicate that OPP is supported?

  * @return True if OPP is supported. False if OPP is not supported.

  */

TBool CBtDiscover::IsOPPSupported() const

	{

	LOG1("CBtDiscover::IsOPPSupported iOPPPort: %d", iOPPPort);

	if(iOPPPort)

		return ETrue;

	else

		return iOPPPort;

	}

/**

  * @brief Obtain Bluetooth device class.

  *

  * @return Bluetooth device class. Used by CRsBtDiscoverEngine to do the first check

  * whether the current Bluetooth device is likely to support BPP or OPP.

  * @sa KBTMinDevClassPrinter

  */

TBTDeviceClass CBtDiscover::GetDeviceClass() const

	{

	TInquirySockAddr sockAddr = (TInquirySockAddr)iNameEntry().iAddr;

	TBTDeviceClass devClass(sockAddr.MajorServiceClass(),

		sockAddr.MajorClassOfDevice(),

		sockAddr.MinorClassOfDevice());