diff -r 000000000000 -r 3553901f7fa8 telephonyprotocols/psdagt/inc/psdstates.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyprotocols/psdagt/inc/psdstates.h Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,398 @@ +/** +* Copyright (c) 2003-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: +* Header for PSD States +* +* +*/ + + + +/** + @file PSDStates.h + @internalComponent +*/ + + +#ifndef __PSDSTATES_H__ +#define __PSDSTATES_H__ + +#include +#include +#include "psdagt.h" +#include "PSDAGTBase.h" + +class MPsdEnv; +class MPsdCommDbAccess; +class CPsdInitBase : public CAgentStateBase +/** +Base class for classes performing the initialisation state for both +incomming and outgoing connections + +@internalComponent +*/ + { +public: + CPsdInitBase(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdInitBase(); + virtual void StartState(); +protected: + virtual void DoStartStateL(); + void GetPhoneInfoL(const TDesC& aLoadedTsyName, RTelServer::TPhoneInfo& aInfo); + virtual void RunL(); + virtual void DoCancel(); +protected: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + +class CPsdOutInit : public CPsdInitBase +/** +Class implementing the initialisation state for outgoing connections + +@internalComponent +*/ + { +public: + CPsdOutInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdOutInit(); + virtual CAgentStateBase* NextStateL(TBool aContinue); + }; + + +#ifndef INCOMING_NOT_SUPORTED + +class CPsdInInit : public CPsdInitBase +/** +Class implementing the initialisation state for incomming connections + +@internalComponent +*/ + { +public: + CPsdInInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdInInit(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + virtual void DoStartStateL(); + }; +#endif // #ifndef INCOMING_NOT_SUPORTED + + +class CPsdCheckConfig : public CAgentStateBase +/** +Base class for classes performing the config checking state for both +incomming and outgoing connections + +@internalComponent +*/ + { +public: + CPsdCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdCheckConfig(); + virtual void StartState(); +protected: + virtual void DoInitL(); + virtual void RunL(); + virtual void DoCancel(); +protected: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + +class CPsdOutCheckConfig : public CPsdCheckConfig +/** +Class implementing the config checking state for outgoing connections + +@internalComponent +*/ + { +public: + CPsdOutCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdOutCheckConfig(); + virtual CAgentStateBase* NextStateL(TBool aContinue); + }; + + +#ifndef INCOMING_NOT_SUPORTED + +class CPsdInCheckConfig : public CPsdCheckConfig +/** +Class implementing the config checking state for incomming connections + +@internalComponent +*/ + { +public: + CPsdInCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdInCheckConfig(); + virtual CAgentStateBase* NextStateL(TBool aContinue); + }; +#endif // #ifndef INCOMING_NOT_SUPORTED + + +class CPsdNetworkCheck : public CAgentStateBase +/** +Class implementing the network check state. Responsible for ensuring that +the network is in a suitable state before advancing the state machine + +@internalComponent +*/ + { +public: + CPsdNetworkCheck(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdNetworkCheck(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + void DoNetworkCheck(); +private: + RPacketService::TRegistrationStatus iRegStatus; + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + enum + {EGettingInitialStatus,EWaitingForStatusChange} iSubState; + }; + + +#ifndef INCOMING_NOT_SUPORTED + +class CPsdWaitForIncoming : public CAgentStateBase +/** +Class implementing the wait for incomming state. Used in incomming connections +it is responsible for listening out for an incomming connection, validating the +connection and advancing the state machine. + +@internalComponent +*/ + { +public: + CPsdWaitForIncoming(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdWaitForIncoming(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + RPacketContext::TProtocolType iPdpTypeRequested; + RPacketContext::TProtocolAddress iAddressRequested; + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; +#endif // #ifndef INCOMING_NOT_SUPORTED + + +class CPsdCreateContext : public CAgentStateBase +/** +Class implementing the create context state. Responsible for creating the +context and configuring it with the correct parameters + +@internalComponent +*/ + { +public: + CPsdCreateContext(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdCreateContext(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + +class CPsdCreateQoS : public CAgentStateBase +/** +Class implementing the create QoS state. Responsible for creating the +QoS and configuring it with the correct parameters + +@internalComponent +*/ + { +public: + CPsdCreateQoS(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdCreateQoS(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + +class CPsdActivateContext : public CAgentStateBase +/** +Class implementing the activate context state. Responsible for activating +the previously configured context + +@internalComponent +*/ + { +public: + CPsdActivateContext(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdActivateContext(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + enum + {EActivatingContext,ELoaningCommPort} iSubState; + RCall::TCommPort iCommport; + }; + +class CDataLogger; + +class CPsdOpen : public CAgentStateBase, public MPsdContextChangeObserver, public MDialogProcessorObserver +/** +Class implementing the open state. Responsible for maintaining the connection +reporting progress and logging + +@internalComponent +*/ + { +public: + static CPsdOpen* NewL(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdOpen(); + // From CAgentStateBase + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); + // from MPsdContextChangeObserver + virtual void ReportContextBelowAcceptableQuality(); + virtual void ReportError(TInt aError); + // from MDialogProcessorObserver + virtual void MDPOQoSWarningComplete(TInt aError, TBool aResponse); +private: + void RequestStatusChange(); + CPsdOpen(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + void ConstructL(); + void LogActive(); + void WatchForConfigChangesL(); +protected: + void RunL(); + void DoCancel(); +private: + RPacketContext::TContextStatus iContextStatus; + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + TBool iEventLoggerStarted; + CPsdContextChangeMonitor* iContextChangeMonitor; + }; + + + +class CPsdRecoverCommPort : public CAgentStateBase +/** +Class implementing the recover comm port state. First state during +disconnection it is responsible for recovering the previously loaned +comm port + +@internalComponent +*/ + { +public: + CPsdRecoverCommPort(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdRecoverCommPort(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + + +class CPsdCloseLog : public CAgentStateBase +/** +Class implementing the close log state. Responsible for the discontinuation +of logging + +@internalComponent +*/ + { +public: + CPsdCloseLog(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdCloseLog(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + enum + {EStart,ELoggingFinalValues,EEndingLog} iSubState; + }; + + +class CPsdDeactivation : public CAgentStateBase +/** +Class implementing the deactivation state. Responsible for deactivating the +context + +@internalComponent +*/ + { +public: + CPsdDeactivation(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdDeactivation(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + }; + + +class CPsdClosure : public CAgentStateBase +/** +Class implementing the closure state. Responsible for cleaning up all the +resources used for the connection + +@internalComponent +*/ + { +public: + CPsdClosure(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb); + virtual ~CPsdClosure(); + virtual void StartState(); + virtual CAgentStateBase* NextStateL(TBool aContinue); +protected: + void RunL(); + void DoCancel(); +private: + MPsdEnv* iSM; + MPsdCommDbAccess* iDbPsd; + enum + {EClosureStart,EDeletingContext,EClosureEnd} iSubState; + }; + +#endif