// 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:

//

#ifndef RFCOMMSTATES_H

#define RFCOMMSTATES_H

#include <bt_sock.h>

#include "rfcommsap.h"

#include "rfcommutil.h"

#include "rfcommtypes.h"

// Defines the states for the state pattern used by the rfcomm saps

class CRfcommState;

class CRfcommSAP;

NONSHARABLE_CLASS(CRfcommStateFactory) : public CBase

	{

friend class CRfcommProtocol;

public:

	enum TRfcommStates

		{

		EError,

		EClosed,

		EWaitForMux,

		EWaitForPNResp,

		EWaitForUA,

		EOpen,

		EDisconnect,

		EListening,

		EWaitForSABM,

		EWaitForOutgoingSecurityCheck,

		EWaitForIncomingSecurityCheck,

		EWaitForStart,

		ECloseOnStart,

		EDisconnecting,

	// *** keep next one last ***

		ERfcommMaxState,

		};

	TRfcommState* GetState(const TRfcommStates aState);

	TInt StateIndex(const TRfcommState* aState) const;

	static CRfcommStateFactory* NewL();

	~CRfcommStateFactory();

private:

	CRfcommStateFactory();

	void ConstructL();

	TFixedArray<TRfcommState*, ERfcommMaxState> iStates;

	};

/**

   The base class for all the Rfcomm SAP states.

   This is interface that all state objects participating in the state

   pattern have to adhere to.  It provides a mirror of the interface

   of a SAP, since SAPs pass all actions through to the state object

   to provide stateful behaviour.

   Since States are implemented as flyweight objects, there can be no

   SAP specific state information maintained in the state.  All the

   information specific to the SAP is stored by the SAP, which acts as

   a context for the state.

   Private

**/

NONSHARABLE_CLASS(TRfcommState)

	{

public:

	TRfcommState(CRfcommStateFactory& aFactory);

	// State

	virtual void Enter(CRfcommSAP& aSAP)=0;  // Entry to a state

	virtual void Exit(CRfcommSAP& aSAP)=0;	//	Exiting a state

	// From the socket

	virtual void ActiveOpen(CRfcommSAP& aSAP)=0;

	virtual TInt PassiveOpen(CRfcommSAP& aSAP, TUint aQueSize)=0;

	virtual void Shutdown(CRfcommSAP& aSAP)=0;

	virtual void FastShutdown(CRfcommSAP& aSAP)=0;

	virtual TInt Send(CRfcommSAP& aSAP, const TDesC8& aData)=0;

	virtual void Read(CRfcommSAP& aSAP, TDesC8& aData)=0;

	virtual void Ioctl(CRfcommSAP& aSAP, TUint aLevel, TUint aName, TDes8* aOption)=0;

	virtual void CancelIoctl(CRfcommSAP& aSAP, TUint aLevel, TUint aName)=0;

	virtual void Start(CRfcommSAP& aSAP)=0;

	virtual TInt SetOption(CRfcommSAP& aSAP, TUint aLevel, 

						   TUint aName, const TDesC8 &aOption) =0;

	// From the muxer

	virtual void MuxUp(CRfcommSAP& aSAP)=0;

	virtual void LinkDown(CRfcommSAP& aSAP)=0;

	virtual void IoctlComplete(CRfcommSAP& aSAP, TInt aErr, TUint aLevel,TUint aName, TDesC8* aBuf) =0;

	// From the security requester

	virtual void AccessRequestComplete(CRfcommSAP& aSAP, TInt aResult)=0;

	// frame types

	virtual void SABM(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI)=0;	

	virtual void UA(CRfcommSAP& aSAP)=0;

	virtual void DISC(CRfcommSAP& aSAP)=0;

	virtual void DM(CRfcommSAP& aSAP)=0;

	// mux channel commands

	// Remote parameter negotiation

	virtual void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, CRfcommMuxer& aMux, TUint8 aDLCI)=0;

	virtual void RPNRsp(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction)=0;

	// Parameter negotiation

	virtual void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI)=0;  

	virtual void PNResp(CRfcommSAP& aSAP, TRfcommPortParams& aParams)=0;

	virtual void MSC(CRfcommSAP& aSAP, TUint8 aSignals)=0;// Modem status command

 	virtual void RLS(CRfcommSAP& aSAP, TUint8 aStatus)=0; // Remote line status

	// data	

	virtual void NewData(CRfcommSAP& aSAP, const TDesC8& aData)=0;

	virtual void NotifyNewDataCallback(CRfcommSAP& aSAP)=0;

	virtual void CanSend(CRfcommSAP& aSAP)=0;

	virtual void Error(CRfcommSAP& aSAP, TInt aErr,

					   CRfcommSAP::TErrorTypes aType)=0;

//TRY_CBFC

	virtual TUint8 FreeCredit(CRfcommSAP& aSAP)=0;

	virtual TInt ProxyForRemoteCredit(const CRfcommSAP& aSAP) const =0;

	virtual void SetProxyForRemoteCredit(CRfcommSAP& aSAP, TInt aCredit)=0;

	virtual void ProxyForRemoteCreditDecrement(CRfcommSAP& aSAP)=0;

	virtual void ProxyForRemoteCreditAddCredit(CRfcommSAP& aSAP, TUint8 aCredit)=0;

	virtual TInt LocalCredit(const CRfcommSAP& aSAP) const =0;

	virtual void SetInitialLocalCredit(CRfcommSAP& aSAP, TInt aCredit)=0;

	virtual void LocalCreditDecrement(CRfcommSAP& aSAP)=0;

	virtual void LocalCreditAddCredit(CRfcommSAP& aSAP, TUint8 aCredit)=0;

	// Notification for cloned SAPs waiting for connection.

	virtual void ParentClosed(CRfcommSAP& aSAP)=0;

	// Notifications from sent frames waiting for a response.

	virtual TBool HandleFrameResponseTimeout(CRfcommSAP& aSAP)=0;

protected:

	// Utility Error function

	TInt SignalError(CRfcommSAP& aSAP, TInt aErr, MSocketNotify::TOperationBitmasks aType);

	// State change utility function

	void ChangeState(CRfcommSAP& aSAP, CRfcommStateFactory::TRfcommStates aNewState) const;

	// State panicking functions

	void PanicInState(TRFCOMMPanic aPanic) const;

	void DebugPanicInState(TRFCOMMPanic aPanic) const;

protected:

	// Data

	CRfcommStateFactory& iFactory;  // Get states

#ifdef __FLOG_ACTIVE

	TBuf<48> iName;

#endif

private:

    // Forbid copying

	TRfcommState(const TRfcommState&);

	const TRfcommState& operator=(const TRfcommState&);

	};

#ifdef __FLOG_ACTIVE

#define STATENAME(x) iName=_L(x)

#else

#define STATENAME(x)

#endif

/**

   A state class that provides default behaviours.

   This state provides some default behaviours so that other states

   can simply derive from it and thus pick up a set of default

   behaviours.  This reduces the coding burden for other states.

   For events originating within the Socket, the default behaviour is

   to panic as derived classes should be implementing the correct

   functionality.  For events coming in from the Muxer, we don't

   assume that the derived class will be expecting this event (since

   it has essentially come from the remote end).  Thus the default

   behaviour is to place the SAP into an error state, as this is the

   fail-safe state when the remote end sends us an unexpected event.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateDefault) : public TRfcommState

 	{

public:

	TRfcommStateDefault(CRfcommStateFactory& aFactory);

	// Normal state changes

	virtual void Enter(CRfcommSAP& aSAP);

	virtual void Exit(CRfcommSAP& aSAP);

	// State changes initiated by the SAP. Default is to Panic.

	virtual void ActiveOpen(CRfcommSAP&  aSAP);

	virtual TInt PassiveOpen(CRfcommSAP&  aSAP, TUint aQueSize);

	virtual void Shutdown(CRfcommSAP&  aSAP);

	virtual void FastShutdown(CRfcommSAP&  aSAP);

	virtual TInt Send(CRfcommSAP& aSAP, const TDesC8& aData);

	virtual void Read(CRfcommSAP& aSAP, TDesC8& aData);

	virtual void Ioctl(CRfcommSAP& aSAP, TUint aLevel, TUint aName, TDes8* aOption);

	virtual void CancelIoctl(CRfcommSAP& aSAP, TUint aLevel, TUint aName);

	virtual void Start(CRfcommSAP& aSAP);

	virtual TInt SetOption(CRfcommSAP& aSAP, TUint level, TUint name, const TDesC8& aOption);

	// From the signaller, go to error state

	virtual void MuxUp(CRfcommSAP& aSAP);

	virtual void LinkDown(CRfcommSAP& aSAP);

	virtual void SABM(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI);	//	SABM for listening SAP

	virtual void DISC(CRfcommSAP& aSAP);

	virtual void UA(CRfcommSAP& aSAP);

	virtual void DM(CRfcommSAP& aSAP);

	virtual void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, CRfcommMuxer& aMux, TUint8 aDLCI);

	virtual void RPNRsp(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction);

	virtual void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI);

	virtual void PNResp(CRfcommSAP& aSAP, TRfcommPortParams& aParams);

	virtual void MSC(CRfcommSAP& aSAP, TUint8 aSignals);

	virtual void RLS(CRfcommSAP& aSAP, TUint8 aStatus);

	virtual void NewData(CRfcommSAP& aSAP, const TDesC8& aData);

	virtual void NotifyNewDataCallback(CRfcommSAP& aSAP);

	virtual void CanSend(CRfcommSAP& aSAP);

	virtual void IoctlComplete(CRfcommSAP& aSAP, TInt aErr, TUint aLevel,TUint aName, TDesC8* aBuf);

	virtual void AccessRequestComplete(CRfcommSAP& aSAP, TInt aResult);

	virtual void Error(CRfcommSAP& aSAP, TInt aErr, CRfcommSAP::TErrorTypes aType);

	// Notification for cloned SAPs waiting for connection.

	virtual void ParentClosed(CRfcommSAP& aSAP);

	// Notifications from sent frames waiting for a response.

	virtual TBool HandleFrameResponseTimeout(CRfcommSAP& aSAP);

//TRY_CBFC

	virtual TUint8 FreeCredit(CRfcommSAP& aSAP);

	virtual TInt ProxyForRemoteCredit(const CRfcommSAP& aSAP) const;

	virtual void SetProxyForRemoteCredit(CRfcommSAP& aSAP, TInt aCredit);

	virtual void ProxyForRemoteCreditDecrement(CRfcommSAP& aSAP);

	virtual void ProxyForRemoteCreditAddCredit(CRfcommSAP& aSAP, TUint8 aCredit);

	virtual TInt LocalCredit(const CRfcommSAP& aSAP) const;

	virtual void SetInitialLocalCredit(CRfcommSAP& aSAP, TInt aCredit);

	virtual void LocalCreditDecrement(CRfcommSAP& aSAP);

	virtual void LocalCreditAddCredit(CRfcommSAP& aSAP, TUint8 aCredit);

protected:

	};

/**

   The error state.

   All operations are errors, and cause error signals to be sent to

   the SAP.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateError) : public TRfcommStateDefault

	{

public:

	TRfcommStateError(CRfcommStateFactory& aFactory);

	virtual void Enter(CRfcommSAP& aSAP);

	// State changes initiated by the SAP

	virtual void ActiveOpen(CRfcommSAP& aSAP);

	virtual TInt PassiveOpen(CRfcommSAP& aSAP, TUint /*aQueSize*/);

	virtual void Shutdown(CRfcommSAP& aSAP);

	virtual void FastShutdown(CRfcommSAP& aSAP);

	virtual TInt Send(CRfcommSAP& aSAP, const TDesC8&);

	virtual void Read(CRfcommSAP& aSAP, TDesC8&);

	virtual void Ioctl(CRfcommSAP& aSAP, TUint, TUint, TDes8*);

	virtual void CancelIoctl(CRfcommSAP& aSAP, TUint, TUint);

	virtual void Start(CRfcommSAP& aSAP);

	};

//

// The interesting states start here

//

/**

   Closed - the initial state.

	This state is the initial state of the SAP, as well as the end

	state when a connection is disconnected.  A SAP in this state

	cannot be assumed to have valid remote or local addresses in

	place.

	The invariant on this state is that it will not have a muxer.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateClosed) : public TRfcommStateDefault

	{

public:

	TRfcommStateClosed(CRfcommStateFactory& aFactory);

	virtual void Enter(CRfcommSAP& aSAP);

	// State changes initiated by the SAP

	void ActiveOpen(CRfcommSAP& aSAP);

	TInt PassiveOpen(CRfcommSAP& aSAP, TUint aQueSize);

	void Shutdown(CRfcommSAP&  aSAP);	

	void Error(CRfcommSAP& aSAP, TInt aErr,

					   CRfcommSAP::TErrorTypes aType);

	void Start(CRfcommSAP& aSAP);

	TInt SetOption(CRfcommSAP& aSAP, TUint aLevel, TUint aName, const TDesC8 &aOption);

	};

/**

   A superstate class that provides default behaviours for connecting states.

   Connecting states are the states between closed and open when the

   local side is doing an active open.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateConnecting) : public TRfcommStateDefault

 	{

public:

	TRfcommStateConnecting(CRfcommStateFactory& aFactory);

	// State changes initiated by the SAP. Default is to Panic.

	virtual void Shutdown(CRfcommSAP&  aSAP);

	virtual void FastShutdown(CRfcommSAP&  aSAP);

	virtual void DM(CRfcommSAP& aSAP);

	virtual void LinkDown(CRfcommSAP& aSAP);

protected:

	//	Used to issue appropriate notifications to SAP when

	//	connection fails (CanClose or SignalError)

	virtual void FailureWhileConnecting(CRfcommSAP& aSAP, TInt aErrorCode);

	};

/**

   Waiting for the muxer.

   When the protocol is asked to find the muxer for a SAP, it will

   either find an existing one or bring up a link, create a muxer and

   then use the new one.  Either way, eventually the MuxUp event will

   be generated.

   Once the Mux is up, we then need to send a SABM command.

   Note that a LinkDown event can occur in this state.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateWaitForMux) : public TRfcommStateConnecting

	{

public:

	TRfcommStateWaitForMux(CRfcommStateFactory& aFactory);

	void Enter(CRfcommSAP& aSAP);

	void Shutdown(CRfcommSAP& aSAP);

	void SABM(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI);	

	void UA(CRfcommSAP& aSAP);

	void DISC(CRfcommSAP& aSAP);

	void DM(CRfcommSAP& aSAP);

	// mux channel commands

	// Remote parameter negotiation

	void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, CRfcommMuxer& aMux, TUint8 aDLCI);

	void RPNRsp(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction);

	// Parameter negotiation

	void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI);  

	void PNResp(CRfcommSAP& aSAP, TRfcommPortParams& aParams);

	void MSC(CRfcommSAP& aSAP, TUint8 aSignals);// Modem status command

 	void RLS(CRfcommSAP& aSAP, TUint8 aStatus); // Remote line status

	// data	

	void NewData(CRfcommSAP& aSAP, const TDesC8& aData);

	// State change from the Mux

	void MuxUp(CRfcommSAP& aSAP);

	};

/**

	Waiting for Parameter Negotiation response.

   On successful response, we contine with the connection. On unsuccessful

   response, we signal a socket error and return to the Closed state.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateWaitForPNResp) : public TRfcommStateConnecting

	{

public:

	TRfcommStateWaitForPNResp(CRfcommStateFactory& aFactory);

	void Enter(CRfcommSAP& aSAP);

	// State change from the Mux

	void PNResp(CRfcommSAP& aSAP, TRfcommPortParams& aParams);

	};

/**

   Wait For UA state (subclass of Connecting state).

   State in which we are waiting for a reponse to our SABM command.

   On successful connect we send an MSC (modem status command) and

   enter the open state.

   Private

**/

NONSHARABLE_CLASS(TRfcommStateWaitForUA) : public TRfcommStateConnecting

	{

public:

	TRfcommStateWaitForUA(CRfcommStateFactory& aFactory);

	// mux events

	void UA(CRfcommSAP& aSAP);

	// Notifications from sent frames waiting for a response.

	TBool HandleFrameResponseTimeout(CRfcommSAP& aSAP);

	};

/**

   Waiting for the outgoing security check to complete.

   This is the state while we wait for the SecMan to give a go/no-go

   on this connection.

**/

NONSHARABLE_CLASS(TRfcommStateOutgoingSecurityCheck) : public TRfcommStateConnecting

	{

public:

	TRfcommStateOutgoingSecurityCheck(CRfcommStateFactory& aFactory);

	// mux events

	void Enter(CRfcommSAP& aSAP);

	void AccessRequestComplete(CRfcommSAP& aSAP, TInt aResult);

	void Exit(CRfcommSAP& aSAP);

	};

/**

	Listening State

	State that the SAP enters following a PassiveOpen.

    Private

**/

NONSHARABLE_CLASS(TRfcommStateListening) : public TRfcommStateDefault

	{

public:

	TRfcommStateListening(CRfcommStateFactory& aFactory);

	void Enter(CRfcommSAP& aSAP);

	void Exit(CRfcommSAP& aSAP);

	void SABM(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI);

	void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI);

	void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, CRfcommMuxer& aMux, TUint8 aDLCI);

	void Shutdown(CRfcommSAP& aSAP);

	void FastShutdown(CRfcommSAP& aSAP);

	TInt SetOption(CRfcommSAP& aSAP, TUint aLevel, TUint aName, const TDesC8 &aOption);

private:

	CRfcommSAP* AttemptToClone(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI);

	};

/**

   Base state for cloned saps before they are taken over by ESOCK.

   This base state handles a bunch of the error handling for the

   derived states.

**/

NONSHARABLE_CLASS(TRfcommStateCloned) : public TRfcommStateDefault

	{

public:

	TRfcommStateCloned(CRfcommStateFactory& aFactory);

	void LinkDown(CRfcommSAP& aSAP);

	void Error(CRfcommSAP& aSAP, TInt aErr,

			   CRfcommSAP::TErrorTypes aType);

	void DISC(CRfcommSAP& aSAP);

	void DM(CRfcommSAP& aSAP);

	};	

/**

	The Wait For SABM state.

	The state that cloned SAPs start off in before receiving

	a PN or SABM.

    Private

**/

NONSHARABLE_CLASS(TRfcommStateWaitForSABM) : public TRfcommStateCloned

	{

public:

	TRfcommStateWaitForSABM(CRfcommStateFactory& aFactory);

	void SABM(CRfcommSAP& aSAP, CRfcommMuxer& aMux, TUint8 aDLCI);

	void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, 

			 CRfcommMuxer& aMux, TUint8 aDLCI);

	void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI);

	void MuxUp(CRfcommSAP& aSAP);

	};

/**

   Waiting for the incoming security check to complete.

   This is the state while we wait for the SecMan to give a go/no-go

   on this connection.  We will respond to SABM with a DM if the

   answer is no.

**/

NONSHARABLE_CLASS(TRfcommStateIncomingSecurityCheck) : public TRfcommStateCloned

	{

public:

	TRfcommStateIncomingSecurityCheck(CRfcommStateFactory& aFactory);

	void Enter(CRfcommSAP& aSAP);

	void AccessRequestComplete(CRfcommSAP& aSAP, TInt aResult);

	void Exit(CRfcommSAP& aSAP);

	};

/**

	The Wait For Start state.

	The state that cloned SAPs arrive in after receiving a SABM

    Private

**/

NONSHARABLE_CLASS(TRfcommStateWaitForStart) : public TRfcommStateDefault

	{

public:

	TRfcommStateWaitForStart(CRfcommStateFactory& aFactory);

	void Enter(CRfcommSAP& aSAP);

	void Start(CRfcommSAP& aSAP);

	void DISC(CRfcommSAP& aSAP);

	void Error(CRfcommSAP& aSAP, TInt aErr,

				CRfcommSAP::TErrorTypes aType);

	};

/**

	The Close On Start state