// Copyright (c) 1997-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:

// BTComm state machine state implementation.

// 

//

#include <bluetooth/logger.h>

#include <cs_port.h>

#include "btcomm.h"

#include "btstate.h"

#include "btcommactive.h"

#include <bt_sock.h>

#include "sdpkey.h"

#include "sdpclientcsy.h"

#include <e32test.h>

#include <btmanclient.h>

#include "btcommutil.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_COMM);

#endif

#define BAD_BTCOMM_EVENT PanicInState(EBTCommBadEventForThisState);

TBTPortState::TBTPortState(CBTPortStateFactory* aParent)

	: iFactory(aParent)

/**

	TBTPortState c'tor.

	TBTPortState is the abstract base class that all CSY state

	objects inherit from.  However, it is not a 'C' class but 

	a 'T' class which is slightly bogus but the best way to 

	implement the base state for the pattern.

**/

	{

	LOG_FUNC

	}

TBTPortState::~TBTPortState()

	{

	LOG_FUNC

	}

/**

Calls the appropriate panic function to encode the panic

code with the current state identifier.

@param aPanic The panic code that the state is panicking with.

*/

void TBTPortState::PanicInState(TBTCommPanic aPanic) const

	{

	LOG_FUNC

	BTCommUtil::Panic(aPanic, iFactory->StateIndex(this));

	}

//		***** Default state *****

TBTPortDefaultState::TBTPortDefaultState(CBTPortStateFactory* aParent) 

	: TBTPortState(aParent)

	{

	LOG_FUNC

	}

TBTPortDefaultState::~TBTPortDefaultState()

	{

	LOG_FUNC

	}

void TBTPortDefaultState::Open(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::Close(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::Read(CBTPortProxy* /*aContext*/,TAny* /*aPtr*/,TInt /*aLength*/)

/**

	TBTPortDefaultState Read.

**/

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::Write(CBTPortProxy* /*aContext*/,TAny* /*aPtr*/,TInt /*aLength*/)

/**

	TBTPortDefaultState Write.

**/

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::ReadCancel(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::WriteCancel(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::DoRunL(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::DoCancel(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::DoLockedAction(CBTPortProxy* /*aContext*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::DoWriteCompleted(CBTPortProxy* /*aContext*/,TInt /*aError*/)

	{

	LOG_FUNC

	BAD_BTCOMM_EVENT

	}

void TBTPortDefaultState::DoReadCompleted(CBTPortProxy* /*aContext*/,TInt aError) 

	{ 

	// because we managed to get reopened before destruction 

	// and this event sources from the reader's request completing 

	// after a read cancel was issued from the closing. 

	LOG_FUNC

	if(aError==KErrCancel) {return;}  

	BAD_BTCOMM_EVENT 

	} 

void TBTPortDefaultState::Error(CBTPortProxy* aContext,TInt aError)

/**

	This will call each state's error loging and move the CSY to the error state.

*/

	{

	LOG_FUNC

	LogStateError(aContext,aError);

	aContext->iLastError=aError; // record this before we lose context

	aContext->MoveToErrorState();

	}

// ****** Common Pre-Connection I/O Base State  *****

TBTPortCommonBaseState::TBTPortCommonBaseState(CBTPortStateFactory* aParent)

	:TBTPortDefaultState(aParent)

	{

	LOG_FUNC

	}

void TBTPortCommonBaseState::Read(CBTPortProxy* aContext,TAny* aPtr, TInt aLength)

	{

	LOG_FUNC

	if(aLength)

		{

		aContext->iClientReadPtr=aPtr;

		aContext->iClientReadLength=aLength;

		aContext->iClientRemainderToRead=aLength;

#ifdef _DEBUG

	aContext->iReadsPending++;

#endif

		}

	else

		{

		//zero length read, complete it immediately

		aContext->iPort->ReadCompleted(KErrNone);

		}

	}

void TBTPortCommonBaseState::Write(CBTPortProxy* aContext,TAny* aPtr, TInt aLength)

	{

	LOG_FUNC

	aContext->iClientWritePtr=aPtr;

	aContext->iClientWriteLength=aLength;

	aContext->iClientLengthWrittenSoFar=aLength;

	}

void TBTPortCommonBaseState::WriteCancel(CBTPortProxy* aContext)

/**

	Cancel initial Write if there was one or do nothing.

*/

	{

	LOG_FUNC

	if(aContext->iClientWritePtr)

		{

		aContext->iClientWritePtr=NULL;

		aContext->iClientWriteLength=0;

		aContext->iClientLengthWrittenSoFar=0;

		aContext->iPort->WriteCompleted(KErrCancel);

		}

	}

void TBTPortCommonBaseState::ReadCancel(CBTPortProxy* aContext)

/**

	Cancel initial Read if there was one or do nothing.

*/

	{

	LOG_FUNC

	if(aContext->iClientReadPtr)

		{

		aContext->iClientReadPtr=NULL;

		aContext->iClientReadLength=0;

		aContext->iClientRemainderToRead=0;

#ifdef _DEBUG

		aContext->iReadsPending--;

#endif

		aContext->iPort->ReadCompleted(KErrCancel);

		}

	}

void TBTPortCommonBaseState::Close(CBTPortProxy* aContext)

	{

	LOG_FUNC

	aContext->StopReader();

	//check to see if we had any client requests cached and cancel them

	if(aContext->iClientReadPtr)

		{

		ReadCancel(aContext);

		}	

	if(aContext->iClientWritePtr)

		{

		WriteCancel(aContext);

		}

	aContext->SetState(iFactory->GetState(CBTPortStateFactory::EClosing));

	}

//		***** Idle state *****

TBTPortStateIdle::TBTPortStateIdle(CBTPortStateFactory* aParent)

	:TBTPortCommonBaseState(aParent)

	{

	LOG_FUNC

	}

TBTPortStateIdle::~TBTPortStateIdle()

	{

	LOG_FUNC

	}

void TBTPortStateIdle::Open(CBTPortProxy* aContext)

/**

	This function is the entry point for the BT CSY state machine.

	The first thing we will do is to pretend we opened a BTCOMM connection.

	The reason for this is to avoid any deadlock across the C32-ESock-ETel 

	trilogy.

  **/

	{

	LOG_FUNC

	aContext->CancelShutDownTimer(); // just in case we were going down before this call

	}

void TBTPortStateIdle::Close(CBTPortProxy* aContext)

/**

	A call to this method will cancel any pending requests.

	It will also cancel any transition to any other state.

  */	

	{

	LOG_FUNC

	aContext->Cancel();// any transition

	//check to see if we had any client requests cached and cancel them

	ReadCancel(aContext);	

	WriteCancel(aContext);

	}

void TBTPortStateIdle::Read(CBTPortProxy* aContext,TAny* aPtr,TInt aLength)

/**

	Caches the Read() for completion after the connection is setup, starts the protocol and state machine.

*/

	{

	LOG_FUNC

	LOG(_L("**TBTPortStateIdle::Read -- Queueing one**"));

	TBTPortCommonBaseState::Read(aContext,aPtr,aLength);

	// Connect to ESock

	SockServConnect(aContext);

	}

void TBTPortStateIdle::Write(CBTPortProxy* aContext,TAny* aPtr,TInt aLength)

/**

	Caches the Write() for completion after the connection is setup, starts the protocol and state machine.

*/

	{

	LOG_FUNC

	LOG(_L("**TBTPortStateIdle::Write -- Queueing one**"));

	TBTPortCommonBaseState::Write(aContext,aPtr,aLength);

	// Connect to ESock

	SockServConnect(aContext);

	}

void TBTPortStateIdle::DoRunL(CBTPortProxy* /*aContext*/)

/**

	Will be called only after we  decided to close in the Discovering state.

	This is a NoOp method.

 */

	{

	LOG_FUNC

	}

void TBTPortStateIdle::SockServConnect(CBTPortProxy* aContext)

/**

	Makes an asynchronous attempt to connect to ESock and moves to the next state.

**/

	{

	LOG_FUNC

	aContext->iSockServConnector->SockServConnect(aContext->iStatus);

	// now move to the next state where we pre-load the protocol

	aContext->SetState(iFactory->GetState(CBTPortStateFactory::ELoadingProtocol));

	aContext->SetActive();

	}

void TBTPortStateIdle::LogStateError(CBTPortProxy* /*aContext*/,TInt /*aError*/)

	{

	LOG_FUNC

	}

//		***** Loading Protocol state *****

TBTPortStateLoadingProtocol::TBTPortStateLoadingProtocol(CBTPortStateFactory* aParent)

	:TBTPortCommonBaseState(aParent), iClosePending(EFalse)

	{

	LOG_FUNC

	}

TBTPortStateLoadingProtocol::~TBTPortStateLoadingProtocol()

	{

	LOG_FUNC

	}

void TBTPortStateLoadingProtocol::Read(CBTPortProxy* aContext,TAny* aPtr, TInt aLength)

	{

	LOG_FUNC

	// Cache the read ready for when our connection is up. 

	if(aLength)

		{

		aContext->iClientReadPtr=aPtr;

		aContext->iClientReadLength=aLength;

		aContext->iClientRemainderToRead=aLength;

#ifdef _DEBUG

	aContext->iReadsPending++;

#endif

		}

	else

		{

		//zero length read, complete it immediately

		aContext->iPort->ReadCompleted(KErrNone);

		}

	// If we were planning on closing this reopens us - we've cached the read as

	// normal, just unset the close pending flag and we can carry on setting up

	// the connection as normal.

	if(!iClosePending)

		{

		iClosePending = EFalse;

		}

	}

void TBTPortStateLoadingProtocol::Write(CBTPortProxy* aContext,TAny* aPtr, TInt aLength)

	{

	LOG_FUNC

	// Cache the write ready for when our connection is up.  

	aContext->iClientWritePtr=aPtr;

	aContext->iClientWriteLength=aLength;

	aContext->iClientLengthWrittenSoFar=aLength;

	// If we were planning on closing this reopens us - we've cached the write as

	// normal, just unset the close pending flag and we can carry on setting up

	// the connection as normal.

	if(iClosePending)

		{

		iClosePending = EFalse;

		}

	}

void TBTPortStateLoadingProtocol::Close(CBTPortProxy* aContext)

/**

	A call to this method will cancel any pending requests.

	It will also cancel any transition to any other state.

  */	

	{

	LOG_FUNC

	// If we're in this state our connection attempt on ESock hasn't

	// completed yet.  We can't transition to the closing state yet 

	// because we don't have the handle for our ESock session which 

	// we need to close.  When the connection request completes we'll 

	// do the transition, unless there's a Read or Write before then, 

	// when we'll allow the connection set up to continue.

	//check to see if we had any client requests cached and cancel them

	ReadCancel(aContext);	

	WriteCancel(aContext);

	// Set the flag so we know where to go when the Esock connect has

	// completed

	iClosePending = ETrue;

	}

void TBTPortStateLoadingProtocol::DoRunL(CBTPortProxy* aContext)

/**

	Will be called only after we  decided to close in the Discovering state.

	This is a NoOp method.

 */

	{

	LOG_FUNC

	if (aContext->iStatus != KErrNone)

		{

		Error(aContext, aContext->iStatus.Int());	// couldn't connect to esock

		return;

		}

	// If we're waiting for the ESock handle to allow us to close, transition

	// to the closing state now, otherwise continue connection set up.

	if(iClosePending)

		{

		aContext->SetState(iFactory->GetState(CBTPortStateFactory::EClosing));

		aContext->SetActive();

		TRequestStatus* pStatus = &(aContext->iStatus);

		User::RequestComplete(pStatus, KErrNone);

		// Reset this incase we come back through the state machine later

		iClosePending = EFalse;

		}

	else

		{

		StartProtocol(aContext);

		}

	}

void TBTPortStateLoadingProtocol::StartProtocol(CBTPortProxy* aContext)

/**

	Makes an asynchronous attempt to invoke RSocketServ::StartProtocol() and moves to the next state.

**/

	{

	LOG_FUNC

    // now async load Bluetooth RFComm protocol to stop comm port open thread lock.

	RSocketServ &sockServ = aContext->iSockServ;

	LOG1(_L("TBTPortStateLoadingProtocol::Start L2CAP Protocol OK, iSockServ=0x%x"),sockServ.Handle());

    sockServ.StartProtocol(KBTAddrFamily,KSockSeqPacket,KL2CAP,aContext->iStatus);

	// now move to the next state were the results will be handled

	aContext->SetState(iFactory->GetState(CBTPortStateFactory::EDiscovering));

	aContext->SetActive();

	}

void TBTPortStateLoadingProtocol::LogStateError(CBTPortProxy* /*aContext*/,TInt /*aError*/)

	{

	LOG_FUNC

	}

//		***** Discovering state *****

TBTPortStateDiscovering::TBTPortStateDiscovering(CBTPortStateFactory* aParent)

	: TBTPortCommonBaseState(aParent)

	{

	LOG_FUNC

	}

TBTPortStateDiscovering::~TBTPortStateDiscovering()

	{

	LOG_FUNC

	}

void TBTPortStateDiscovering::DoRunL(CBTPortProxy* aContext)

/**

	Find-out the port's corresponding device and settings.

	This is done by looking at the registry default settings for this 

	BTComm port. 

**/

	{

	LOG_FUNC

	TInt ret=aContext->iStatus.Int();

	if (ret!=KErrNone)

		{// could not start Bluetooth protocol 

		// must error here so that the user notices this

		Error(aContext,ret);

		LOG(_L(" Could not load Bluetooth protocol !"));		

		// do tidy up here

		return;

		}

	else

		{// we have successfully started Bluetooth, lets discover the settings for this port

		aContext->iDefaultService.SetPort(aContext->iPortNo);

		ret=aContext->iPortSettings.Get(aContext->iDefaultService); 

		if(ret!=KErrNone)

			{

			LOG(_L(" Could not find default device !"));