--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btstack/rfcomm/rfcommstates.h Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,650 @@
+// 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
+
+ State arrived at when a disconnect is sent to a SAP which is
+ waiting for a Start. A SAP in this state will disconnect
+ immediately that a Start is called on it.
+
+ Private
+**/
+NONSHARABLE_CLASS(TRfcommStateCloseOnStart) : public TRfcommStateDefault
+ {
+public:
+ TRfcommStateCloseOnStart(CRfcommStateFactory& aFactory);
+ void Start(CRfcommSAP& aSAP);
+ void Error(CRfcommSAP& aSAP, TInt aErr,
+ CRfcommSAP::TErrorTypes aType);
+ };
+
+/**
+ The open state.
+
+ The channel is connected and the data can now flow.
+
+ Private
+**/
+
+NONSHARABLE_CLASS(TRfcommStateOpen) : public TRfcommStateDefault
+ {
+public:
+ TRfcommStateOpen(CRfcommStateFactory& aFactory);
+
+ void Enter(CRfcommSAP& aSAP);
+ void PerformDataAwareStateChange(CRfcommSAP& aSAP);
+ // From ESOCK
+ void Exit(CRfcommSAP& aSAP);
+ void Shutdown(CRfcommSAP& aSAP);
+ void FastShutdown(CRfcommSAP& aSAP);
+ TInt Send(CRfcommSAP& aSAP, const TDesC8& aData);
+ void Read(CRfcommSAP& aSAP, TDesC8& aData);
+ void Ioctl(CRfcommSAP& aSAP,TUint aLevel,TUint aName,TDes8* aOption);
+
+ // From mux
+ void NewData(CRfcommSAP& aSAP, const TDesC8& aData);
+ void NotifyNewDataCallback(CRfcommSAP& aSAP);
+ void CanSend(CRfcommSAP& aSAP);
+ void IoctlComplete(CRfcommSAP& aSAP, TInt aErr, TUint aLevel,TUint aName, TDesC8* aBuf);
+ void MSC(CRfcommSAP& aSAP, TUint8 aSignals);
+ void RPN(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction, CRfcommMuxer& aMux, TUint8 aDLCI);
+ void RPNRsp(CRfcommSAP& aSAP, const TRfcommRPNTransaction& aRPNTransaction);
+ void PN(CRfcommSAP& aSAP, TRfcommPortParams& aParams, CRfcommMuxer& aMux, TUint8 aDLCI);
+ void RLS(CRfcommSAP& aSAP, TUint8 /*aStatus*/);
+ void DISC(CRfcommSAP& aSAP);
+ void DM(CRfcommSAP& aSAP);
+ void LinkDown(CRfcommSAP& aSAP);
+ TInt SetOption(CRfcommSAP &aSAP, TUint aLevel, TUint aName, const TDesC8& aOption);
+//TRY_CBFC
+ TUint8 FreeCredit(CRfcommSAP& aSAP);
+
+ virtual TInt ProxyForRemoteCredit(const CRfcommSAP& aSAP) const;
+#ifndef __GCC32__
+ using TRfcommStateDefault::ProxyForRemoteCredit; //unhide other overloads;
+#endif
+ virtual TInt LocalCredit(const CRfcommSAP& aSAP) const;
+#ifndef __GCC32__
+ using TRfcommStateDefault::LocalCredit; //unhide other overloads;
+#endif
+ };
+
+/**
+ The disconnect state.
+
+ This is for a SAP on its way to being shutdown.
+
+ Private
+**/
+
+
+NONSHARABLE_CLASS(TRfcommStateDisconnect) : public TRfcommStateDefault
+ {
+public:
+ TRfcommStateDisconnect(CRfcommStateFactory& aFactory);
+
+ void Enter(CRfcommSAP& aSAP);
+ void DISC(CRfcommSAP& aSAP);
+ void UA(CRfcommSAP& aSAP);
+ void DM(CRfcommSAP& aSAP);
+ void LinkDown(CRfcommSAP& aSAP);
+private:
+ // Code common to UA, DM and DISC
+ void DisconnectComplete(CRfcommSAP& aSAP);
+ };
+
+/**
+ Disconnecting state.
+
+ Here the remote end has shut down the DLCI, but we have still got
+ data to send up to the socket. We wait for the data to drain
+ before calling Disconnect(). If the client tries to write, we
+ immediately signal Disconnect() as we are no longer able to write.
+ After Disconnect() we move to state closed.
+
+ In this state we are not associated with a mux, as we no longer
+ want events from the link.
+
+ Private
+**/
+NONSHARABLE_CLASS(TRfcommStateDisconnecting) : public TRfcommStateDefault
+ {
+public:
+ TRfcommStateDisconnecting(CRfcommStateFactory& aFactory);
+
+ void Enter(CRfcommSAP& aSAP);
+ void Shutdown(CRfcommSAP& aSAP);
+ void FastShutdown(CRfcommSAP& aSAP);
+ TInt Send(CRfcommSAP& aSAP, const TDesC8& aData);
+ void Read(CRfcommSAP& aSAP, TDesC8& aData);
+ void Ioctl(CRfcommSAP& aSAP,TUint aLevel,TUint aName,TDes8* aOption);
+ void NotifyNewDataCallback(CRfcommSAP& aSAP);
+
+private:
+ };
+
+
+#include "rfcommstates.inl"
+#endif
+