bluegpsengine.cpp

S60系统下的蓝牙GPS连接程序 包括client和server端的连接方式

/*****************************************************************************
 COPYRIGHT All rights reserved Sony Ericsson Mobile Communications AB 2003.

 The software is the copyrighted work of Sony Ericsson Mobile Communications AB.
 The use of the software is subject to the terms of the end-user license
 agreement which accompanies or is included with the software. The software is
 provided "as is" and Sony Ericsson specifically disclaim any warranty or
 condition whatsoever regarding merchantability or fitness for a specific
 purpose, title or non-infringement. No warranty of any kind is made in
 relation to the condition, suitability, availability, accuracy, reliability,
 merchantability and/or non-infringement of the software provided herein.

 *****************************************************************************/

#include "BlueGPSEngine.h"


#define infoPrint(text, secs) { \
	RNotifier notifier; \
	notifier.Connect(); \
	notifier.InfoPrint(text); \
	User::After( 1000000 * secs); \
	notifier.Close(); \
	}

/*
 *********************************************************************
 * CBlueGPSEngine
 *
 *********************************************************************
 */
CBlueGPSEngine* CBlueGPSEngine::NewL( CBlueGPSServer* aServer, CBlueGPSParser* aParser )
{
	CBlueGPSEngine* self = new(ELeave) CBlueGPSEngine();
	CleanupStack::PushL( self );
	self->ConstructL( aServer, aParser );
	CleanupStack::Pop();
	return self;
}


TInt CBlueGPSEngine::ReadAddress()
{
	delete iRemoteDevAddr;   
	// Reading from the GPS device address file
	RFs fSession;
	_LIT( KAddrFile, "C:\\documents\\BlueGPS_devAddr.txt");
	RFile addrFile;
	User::LeaveIfError( fSession.Connect() );
	TInt err = addrFile.Open( fSession, KAddrFile, EFileRead );
	if ( err != KErrNone )
	{
		infoPrint( _L("Error reading DevAddrFile"), 2);
		addrFile.Close();
		fSession.Close();
		iDevAddr = &iBuf;
		iRemoteDevAddr = new TBTDevAddr( );
		return KErrGeneral;
	}
	else
	{
		addrFile.Read( 0, iBuf );
		addrFile.Close();
		fSession.Close();

		iDevAddr = &iBuf;
		iRemoteDevAddr = new TBTDevAddr( *iDevAddr );
		return KErrNone;
	}
}


void CBlueGPSEngine::ConstructL( CBlueGPSServer* aServer, 
								 CBlueGPSParser* aParser ) 
{
	iServer = aServer;
	iSocket = new (ELeave) RSocket();
	iPortSeeker = new CServiceSeeker( this );
	iReadBuffer = &iTempBuf;
	iConnected = EFalse;
	iReader = CBTReader::NewL( iSocket, aParser, this, KReadBufferSize );
	User::LeaveIfError(iTimer.CreateLocal());
	iServiceFinder = 0;
	User::LeaveIfError( iRunning.CreateLocal(1) );

	TInt err = ReadAddress();
	if (err != KErrNone)
		iEngineState = ENoValidAddress;
	else 
		iEngineState = EDisconnected;
}
	


void CBlueGPSEngine::ReadDeviceAddressFile()
{
	iRunning.Wait();
	iEngineState = ENewDevice;
	iTimer.After(iStatus, 0);
	SetActive();
	iRunning.Signal();
}


CBlueGPSEngine::CBlueGPSEngine() : CActive(EPriorityStandard) 
{
	CActiveScheduler::Add( this );
}


CBlueGPSEngine::~CBlueGPSEngine()
{
	Cancel();
	iTimer.Close();
	iRunning.Close();
	
	delete iReader;
	delete iServiceFinder;
	delete iRemoteDevAddr;
	delete iPortSeeker;
}


void CBlueGPSEngine::RunL()
{
	Connect();
}


void CBlueGPSEngine::DoCancel()
{
	iTimer.Cancel();
}


void CBlueGPSEngine::Start()
{
	iRunning.Wait();
	if (iEngineState != ENoValidAddress && !IsActive())
	{
		iEngineState = EDisconnected;
		iTimer.After(iStatus, KReconnectTimeout);
		SetActive();
	}
	iRunning.Signal();
}

void CBlueGPSEngine::Stop()
{
	iRunning.Wait();
	Cancel();
	iEngineState = EClosingReader;
	iTimer.After(iStatus, 0);
	SetActive();
	iRunning.Signal();
}


/*
 ****************************************************************
 * Connect()
 *
 ****************************************************************
 */
void CBlueGPSEngine::Connect()
{
	RSocketServ socketServ;
	TProtocolDesc pInfo;
//	TBTDevAddr btAddr( *iDevAddr );

	TInt err;

	switch(iEngineState)
	{
		case EDisconnected:
			iRunning.Wait();
			iServer->SetConnected( EFalse );

			iReader->Cancel();
			iSocket->Close();
			delete iServiceFinder;
			iServiceFinder = 0;

			infoPrint( _L("Connecting..."), 1 );		
			socketServ.Connect();
			User::LeaveIfError( socketServ.FindProtocol(_L("RFCOMM"), pInfo) );
			User::LeaveIfError( iSocket->Open(socketServ, KBTAddrFamily, KSockStream, KRFCOMM) );
			
			iEngineState = EFindingPort;
			iStatus = KRequestPending;

			// Service and attribute discovery
			iServiceFinder = CRFCOMMServiceFinder::NewL( KSerialPortUUID, *iRemoteDevAddr, *iPortSeeker );  // 0x1101
			//iServiceFinder->iPort = 0xFE; // initial invalid port
			iPortSeeker->iPort = 0xFE;
			iServiceFinder->FindPortL(); 
			
			// Will be set active when iPortSeeker has received a valid port... not any more, now a timer
			iTimer.After(iStatus, 100000);
			SetActive();
			break;
		
		
		case EFindingPort:
			if (iPortSeeker->iPort == 0xFE)  // Port nr not changed: not finished finding port, try again
			{
				iTimer.After(iStatus, 100000);
				SetActive();
			}
			else if (iPortSeeker->iPort == 0xFF) // Error finding port, retry from EDisconnected
			{
				iRunning.Signal();
				iEngineState = EDisconnected;
				infoPrint( _L("No device available") , 2 );
				
				iTimer.After(iStatus, 5000000);
				SetActive();
			}

			else
			{
				iRemoteSockAddr.SetPort( iPortSeeker->iPort );		 
				iRemoteSockAddr.SetBTAddr( *iRemoteDevAddr );
				
				iSocket->Connect( iRemoteSockAddr, iStatus );
				iEngineState = EConnecting;
				SetActive();
			}
			break;
			

		case EConnecting:
			if( iStatus == KErrNone )
			{
				infoPrint( _L("Connected"), 2 );
				
				iReader->Enable();
				iReader->IssueRead();
				iEngineState = EConnected;
				iServer->SetConnected( ETrue );

				iRunning.Signal();
				iTimer.After(iStatus, 0);
				SetActive();
			}
			else
			{
				iServer->SetConnected( EFalse );
				iSocket->CancelConnect();
				
				infoPrint( _L("Connection failed!"), 2 );
				_LIT( KText, "Status: " );
				TBuf<32> tBuf(KText);
                tBuf.AppendNum(iStatus.Int());
				infoPrint( tBuf, 2 );

				iEngineState = EDisconnected;
				iRunning.Signal();
				iTimer.After(iStatus, KReconnectTimeout);
				SetActive();
			}
			break;

		case EClosingReader:
			iRunning.Wait();
			iServer->SetConnected( EFalse );

			iReader->Disable();
			iReader->Cancel();
			iSocket->Close();
			infoPrint( _L("Disconnected"), 2);
			iRunning.Signal();
			break;
		

		case ENewDevice:
			iRunning.Wait();
			iReader->Disable();
			iServer->SetConnected( EFalse );
			err = ReadAddress();
			if (err != KErrNone)
			{
				iEngineState = ENoValidAddress;
				infoPrint( _L("No device selected"), 2);
			}
			else
				iEngineState = EDisconnected;
			iRunning.Signal();
			iTimer.After(iStatus, 0);
			SetActive();
		break;


		case ENoValidAddress:
			iRunning.Wait();
			iServer->SetConnected( EFalse );
			iRunning.Signal();
			break;


		case EConnected:
			iRunning.Wait();
			iServer->SetConnected( ETrue );
			iRunning.Signal();
			break;
	}
	return;
}



/*
 *****************************************************************
 * CServiceSeeker::SearchResult()
 *
 *****************************************************************
 */

void CServiceSeeker::SearchResult(TInt aError, TUint8 aPort)
{
	TBuf<32> tBuf;
		
	if( aError == KErrNone )
	{
		iPort = aPort;
//		_LIT( tText, "CServiceSeeker: Found port %d" );
//		tBuf.Format( tText, aPort );
//		infoPrint( tBuf, 1);	
	}
	else 
	{
		iPort = 0xFF;
	}
}



/*
 *****************************************************************
 * CBTReader
 *
 *****************************************************************
 */
CBTReader::CBTReader(CBlueGPSParser *aParser, CBlueGPSEngine* aEngine ) 
			:	CActive(EPriorityStandard), iParser(aParser), iBuffPtr(0,0), iEngine(aEngine)
{
}

CBTReader::~CBTReader()
{
	Cancel();	
    
	if ( iBTSocket ) 
	{
		iBTSocket->Close();
		delete iBTSocket;
	}
	delete iReadBuffer;
	iRunning.Close();
}


void CBTReader::Disable()
{
	iRunning.Wait();
	iClosed = ETrue;
	iRunning.Signal();
}

void CBTReader::Enable()
{
	iRunning.Wait();
	iClosed = EFalse;
	iRunning.Signal();
}

CBTReader* CBTReader::NewL(RSocket* aSocket, CBlueGPSParser* aParser, CBlueGPSEngine* aEngine, TInt aBufSize )
{
	CBTReader* self = new(ELeave) CBTReader( aParser, aEngine );
	CleanupStack::PushL(self);
	self->ConstructL( aSocket, aBufSize );
	CleanupStack::Pop();
	return self;
}


void CBTReader::ConstructL(RSocket* aSocket, TInt aBufSize )
{
	iBTSocket = aSocket;
	CActiveScheduler::Add(this);
	iReadBuffer = HBufC8::NewL(aBufSize);
	User::LeaveIfError( iRunning.CreateLocal(1) );
}


void CBTReader::DoCancel()
{
	iBTSocket->CancelRead();
}


void CBTReader::RunL()
{
	switch ( iStatus.Int() )
	{
		case KErrNone:				// Characters has been read from socket
			iParser->AddData(*iReadBuffer);
			
			if ( !iClosed )
				IssueRead();		// Start reading again
			break;

		case KErrDisconnected:		// The remote device has closed/disconnected
			infoPrint( _L("Disconnected Bluetooth"), 2 );
			
			if ( !iClosed )
				iEngine->Start();
			break;

		default:
			// Should not happen
			infoPrint( _L("Disconnected BT, default"), 2 );
			if ( !iClosed )
				iEngine->Start();
			break;
	}
}


void CBTReader::IssueRead()
{
	iRunning.Wait();
		
	iBuffPtr.Set( iReadBuffer->Des() );
	if ( !IsActive() )
	{
		iStatus = KRequestPending;

		iBTSocket->Read(iBuffPtr, iStatus);
		SetActive();
	}
	iRunning.Signal();
}