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

//

/**

 @file PsdStates.cpp

*/

#include <comms-infras/cagentsmbase.h>

#include <etelpckt.h>

#include <connectprog.h>  // for circuit-switched progress enums

#include <netconerror.h>

#include "psdlogger.h"

#include "psdstates.h"

#include "psdagt.h"

#include "psdprog.h"

#include <logengevents.h>

CPsdOutInit::CPsdOutInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CPsdInitBase(aObserver,aPsdSM,aDb)

/**

Constructor

*/

	{}

CPsdOutInit::~CPsdOutInit()

/**

Destructor

*/

	{}

CAgentStateBase* CPsdOutInit::NextStateL(TBool aContinue)

/**

Called by the genconn state machine frame work to move the state machine to the next state

function creates the next state in the state machine

@param TBool aContinue flag indicating if the state machine wishes to continue the connection or close it down

@return CAgentStateBase* pointer to the next state in the state machine the calling function takes ownership of the returned object

*/

	{

	if (iStatus==KErrNone && aContinue)	// which it will be if there has been no error so far

		return new (ELeave) CPsdOutCheckConfig(iSMObserver,iSM,iDbPsd);

	else

		return new (ELeave) CPsdClosure(iSMObserver,iSM,iDbPsd);

	}

CPsdOutCheckConfig::CPsdOutCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CPsdCheckConfig(aObserver,aPsdSM,aDb)

/**

Constructor

*/

	{}

CPsdOutCheckConfig::~CPsdOutCheckConfig()

/**

Destructor

*/

	{}

CAgentStateBase* CPsdOutCheckConfig::NextStateL(TBool aContinue)

/**

move the state machine to the next state function creates the next state in the state machine.

@see CAgentStateBase* CPsdOutInit::NextStateL(TBool aContinue)

*/

	{

	if (iStatus==KErrNone && aContinue)	// which it will be if there has been no error so far

		return new (ELeave) CPsdNetworkCheck(iSMObserver,iSM,iDbPsd);

	else

		return new (ELeave) CPsdClosure(iSMObserver,iSM,iDbPsd);

	}

#ifndef INCOMING_NOT_SUPORTED

CPsdInInit::CPsdInInit(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CPsdInitBase(aObserver,aPsdSM,aDb)

/**

Constructor

*/

	{}

CPsdInInit::~CPsdInInit()

/**

Destructor

*/

	{}

void CPsdInInit::DoStartStateL()

/**

Internal function that initialises the state machine for an incoming connection

overriding the virtual function in the base class

Check first of all whether we are allowed to do inbound

*/

	{

	TBool allowed = iDbPsd->IsIncomingAllowedL();

	if (!allowed)

		User::Leave(KErrAccessDenied);

	CPsdInitBase::DoStartStateL();

	}	

CAgentStateBase* CPsdInInit::NextStateL(TBool aContinue)

/**

Called by the genconn state machine frame work to move the state machine to the next state

function creates the next state in the state machine

@see CAgentStateBase* CPsdOutInit::NextStateL(TBool aContinue)

*/	

	{

	if (iStatus==KErrNone && aContinue)	// which it will be if there has been no error so far

		return new (ELeave) CPsdInCheckConfig(iSMObserver,iSM,iDbPsd);

	else

		return new (ELeave) CPsdClosure(iSMObserver,iSM,iDbPsd);

	}

CPsdInCheckConfig::CPsdInCheckConfig(MAgentObserver* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CPsdCheckConfig(aObserver,aPsdSM,aDb)

/**

Constructor

*/

	{}

CPsdInCheckConfig::~CPsdInCheckConfig()

/**

Destructor

*/

	{}

CAgentStateBase* CPsdInCheckConfig::NextStateL(TBool aContinue)

/**

@see CAgentStateBase* CPsdOutInit::NextStateL(TBool aContinue)

*/

	{

	if (iStatus==KErrNone && aContinue)	// which it will be if there has been no error so far

		return new (ELeave) CPsdWaitForIncoming(iSMObserver,iSM,iDbPsd);

	else

		return new (ELeave) CPsdClosure(iSMObserver,iSM,iDbPsd);

	}

#endif // #ifndef INCOMING_NOT_SUPORTED

CPsdInitBase::CPsdInitBase(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CAgentStateBase(*aObserver),iSM(aPsdSM),iDbPsd(aDb)

/**

Constructor

*/

	{

	__ASSERT_DEBUG(aObserver&&aPsdSM&&aDb, User::Invariant());

	}

CPsdInitBase::~CPsdInitBase()

/**

Desctructor

*/

	{

	Cancel();

	}

void CPsdInitBase::StartState() 

/**

Function called by the genconn state machine framework to start the state

*/

	{

	TRAPD(ret,DoStartStateL());

	if (ret!=KErrNone)

		JumpToRunl(ret);

	}

void CPsdInitBase::DoStartStateL()

/**

Internal function that performs all the initialisation of the common resources

held by the state machine for use by subsequent states

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	iSMObserver->PreventConnectionRetries();

	//

	//	PSD AGX does not allow any more connection retries. It assumes that GenConn has

	//  already done the packet network availability check, so we would only get to this stage

	//	should there be packet network (or if it was unknown).

	RTelServer& etel = iSM->TelServer();

	RPhone& phone = iSM->Phone();

	RPacketService& packetNetwork = iSM->PacketNetwork();

	User::LeaveIfError(etel.Connect());

	TBuf<KCommsDbSvrMaxFieldLength> tsyName;

	iSM->BaseEnv().Db()->GetTsyNameL(tsyName);

	User::LeaveIfError(etel.LoadPhoneModule(tsyName));

	iSM->SetTsyLoaded(ETrue);

	User::LeaveIfError(etel.SetExtendedErrorGranularity(RTelServer::EErrorExtended));

	RTelServer::TPhoneInfo info;

	TInt r=tsyName.Locate('.');

	if (r!=KErrNotFound)

		tsyName.SetLength(r);

	GetPhoneInfoL(tsyName,info);	// If this leaves, TSY should be unloaded

							// when RTelServer handle is closed.

	User::LeaveIfError(phone.Open(etel,info.iName));

	User::LeaveIfError(packetNetwork.Open(phone));

	//

	RPhone::TStatus status;

	User::LeaveIfError(phone.GetStatus(status));

	if (status.iModemDetected==RPhone::EDetectedNotPresent || status.iModemDetected==RPhone::EDetectedUnknown)

		{

		phone.Initialise(iStatus);

		SetActive();

		}

	else	// status.iModemDetected==RPhone::EDetectedPresent

		JumpToRunl(KErrNone);

	}

void CPsdInitBase::GetPhoneInfoL(const TDesC& aLoadedTsyName, RTelServer::TPhoneInfo& aInfo)

/**

Function obtains the info on the phone object implemented in the TSY

Assumes aloadedTsyName has no ".TSY" appendage

Finds the phone information for the TSY just loaded. 

Assumes just one phone in that TSY - or that every phone in it is equally useful.

@param name of the loaded Tsy.

@param information about the phone.

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	TInt count;

	User::LeaveIfError(iSM->TelServer().EnumeratePhones(count));

	if (count<=0)

		User::Leave(KErrNotFound);

	TBool found=EFalse;

	for (TInt i=0; i<count; i++)

		{

		TBuf<KCommsDbSvrMaxFieldLength> currentTsyName;

		User::LeaveIfError(iSM->TelServer().GetTsyName(i,currentTsyName));

		TInt r=currentTsyName.Locate('.');

		if (r!=KErrNotFound)

			currentTsyName.SetLength(r);

		if (currentTsyName.CompareF(aLoadedTsyName)==KErrNone)

			{

			User::LeaveIfError(iSM->TelServer().GetPhoneInfo(i,aInfo));

			found=ETrue;

			break;

			}	

		}

	if (!found)

		User::Leave(KErrNotFound);

	}

void CPsdInitBase::RunL()

/**

Complete state for the initialisation state for both incomming and outgoing connections.

*/

	{

	if (iStatus!=KErrNone)

		iSMObserver->ConnectionComplete(EPsdStartingConfiguration,iStatus.Int()); // correct progress?

	else

		iSM->BaseEnv().CompleteState(KErrNone);	// this tells the SM to move onto the next state

	}

void CPsdInitBase::DoCancel()

/**

Cancell the asynchronous request of initialisation state for both incomming and outgoing connections.

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	iSM->Phone().InitialiseCancel();

	}

CPsdCheckConfig::CPsdCheckConfig(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CAgentStateBase(*aObserver),iSM(aPsdSM),iDbPsd(aDb)

/**

Constructor

*/

	{}

CPsdCheckConfig::~CPsdCheckConfig()

/**

Destructor

*/

	{

	Cancel();

	}

void CPsdCheckConfig::StartState()

/**

Start checking Configuration states.

*/

	{

	JumpToRunl(KErrNone);

	}

void CPsdCheckConfig::DoInitL()

	{

	RPacketService& packetNetwork = iSM->PacketNetwork();

	const CPsdContextConfig& config = iSM->Config();

	if(!config.IsConfigSupportedL(packetNetwork,iSM->Direction()) )

		{

		User::Leave(KErrNotSupported);

		}

	}

void CPsdCheckConfig::RunL()

/**

Complete state for the config checking state for both incomming and outgoing connections.

*/

	{

	TRAPD(ret,DoInitL());

	iStatus=ret;

	if (iStatus!=KErrNone)

		iSMObserver->ConnectionComplete(EPsdStartingConfiguration,ret); // correct progress?

	else

		iSM->BaseEnv().CompleteState(KErrNone);	// this tells the SM to move onto the next state

	}

void CPsdCheckConfig::DoCancel()

/**

Need do nothing since StartState() already triggered the request status.

*/

	{}

CPsdNetworkCheck::CPsdNetworkCheck(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CAgentStateBase(*aObserver),iSM(aPsdSM),iDbPsd(aDb)

/**

Constructor

*/

	{

	__ASSERT_DEBUG(aObserver&&aPsdSM&&aDb, User::Invariant());

	}

CPsdNetworkCheck::~CPsdNetworkCheck()

/**

Destructor

*/

	{

	Cancel();

	}

void CPsdNetworkCheck::StartState()

/**

Function called by the genconn state machine framework to start the state

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	__ASSERT_DEBUG(iSMObserver,User::Invariant());

	iSubState = EGettingInitialStatus;

	iSM->PacketNetwork().GetNtwkRegStatus(iStatus,iRegStatus);

	SetActive();

	}

void CPsdNetworkCheck::DoNetworkCheck()

/**

Checking for Network

*/

	{

	__ASSERT_DEBUG(iSMObserver,User::Invariant());

	if (iRegStatus==RPacketService::ERegistrationDenied || 

		iRegStatus==RPacketService::ENotRegisteredNotSearching || 

		iRegStatus==RPacketService::ENotRegisteredAndNotAvailable)

		{

		JumpToRunl(KErrNetConNoGPRSNetwork);

		return;

		}

	if (iRegStatus==RPacketService::ERegisteredOnHomeNetwork || 

		iRegStatus==RPacketService::ERegisteredRoaming ||

		iRegStatus==RPacketService::ENotRegisteredButAvailable ||

		iRegStatus==RPacketService::EUnknown)

		{

		iSM->BaseEnv().CompleteState(KErrNone);

		return;

		}

	__ASSERT_ALWAYS(iRegStatus==RPacketService::ENotRegisteredSearching,PanicAgt(EPsdInvalidNtwkRegistration));

	iSM->PacketNetwork().NotifyChangeOfNtwkRegStatus(iStatus,iRegStatus);

	SetActive();	

	}

void CPsdNetworkCheck::RunL()

/**

iRegStatus should have been updated, if aError is KErrNone

Complete Connection for the Network Check state.

*/

	{

	if(iSubState == EGettingInitialStatus)

		{

		if(iStatus==KErrNotSupported)

		//tsy could not provide the information

			{

			iRegStatus=RPacketService::EUnknown;

			iStatus=KErrNone;

			}

		iSubState = EWaitingForStatusChange;

		}

	if (iStatus==KErrNone)

		DoNetworkCheck();

	else

		iSMObserver->ConnectionComplete(EPsdStartingConfiguration,iStatus.Int());

	}

void CPsdNetworkCheck::DoCancel()

/**

Cancell Asynchronous request of network check state.

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	iSM->PacketNetwork().CancelAsyncRequest(EPacketNotifyChangeOfNtwkRegStatus);

	}

CAgentStateBase* CPsdNetworkCheck::NextStateL(TBool aContinue)

/**

Called by the genconn state machine frame work to move the state machine to the next state

function creates the next state in the state machine

@see CAgentStateBase* CPsdOutInit::NextStateL(TBool aContinue).

*/

	{

	if (iStatus==KErrNone && aContinue)

		return new (ELeave) CPsdCreateContext(iSMObserver,iSM,iDbPsd);

	else 

		return new (ELeave) CPsdClosure(iSMObserver,iSM,iDbPsd);

	}

#ifndef INCOMING_NOT_SUPORTED

CPsdWaitForIncoming::CPsdWaitForIncoming(MAgentStateMachineEnv* aObserver,MPsdEnv* aPsdSM, MPsdCommDbAccess* aDb)

: CAgentStateBase(*aObserver),iSM(aPsdSM),iDbPsd(aDb)

/**

Constructor

*/

	{

	__ASSERT_DEBUG(aObserver&&aPsdSM&&aDb, User::Invariant());

	}

CPsdWaitForIncoming::~CPsdWaitForIncoming()

/**

Destructor

*/

	{

	Cancel();

	}

void CPsdWaitForIncoming::StartState()

/**

Function called by the genconn state machine framework to start the state

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	iSM->PacketNetwork().NotifyContextActivationRequested(iStatus,iPdpTypeRequested,iAddressRequested);

	SetActive();

	}

void CPsdWaitForIncoming::RunL()

/**

Rejects any incoming request for an IP address that isn't in our Incoming context config

Complete Connection for wait for incomming state.

*/

	{

	__ASSERT_DEBUG(iSM,User::Invariant());

	__ASSERT_DEBUG(iSMObserver,User::Invariant());

	if (iStatus==KErrNone)

		{

		if(iSM->Config().QueryIfIncommingConnectionAcceptable(iPdpTypeRequested,iAddressRequested) )

			{

			iSMObserver->UpdateProgress(EPsdAnsweringIncoming,KErrNone);

			TInt ret = iSMObserver->IncomingConnectionReceived();	// to switch NIFMAN to connecting

										// if this returns an error, it means NIFMAN is already

										// connected (this can only happen in the "window" 

										// during callback

			if (ret==KErrNone)

				iSM->BaseEnv().CompleteState(KErrNone);

			else

				{

				iSM->PacketNetwork().RejectActivationRequest();

				StartState();

				}

			}

		else	// wrong address

			{