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

//

/**

 @file PSDAgt.cpp

*/

#include <cdbcols.h>

#include "psdagt.h"

#include "psdstates.h"

#include "psdlogger.h"

CPsdOutSM* CPsdOutSM::NewL(MAgentNotify& aObserver, CDialogProcessor* aDlgPrc, CCommsDbAccess& aDbAccess)

/**

Function creates an outbound connection state machine

@param MAgentObserver& aObserver an observer which will be called back to notify changes in the connection

@param CDialogProcessor* aDlgPrc a pointer to a dialog processor object for use by the state machine

@param CCommsDbAccess& aDbAccess a reference to the comm Db access object to allow the state machine to obtain details from CommDb

@return CPsdOutSM* the newly created object (ownership of the object is passed to the function caller)

*/

	{

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

	CPsdOutSM* sm = new (ELeave) CPsdOutSM(aObserver,aDlgPrc,aDbAccess);

	CleanupStack::PushL(sm);

	sm->ConstructL();

	CleanupStack::Pop();

	return sm;

	}

CPsdOutSM::CPsdOutSM(MAgentNotify& aObserver, CDialogProcessor* aDlgPrc, CCommsDbAccess& aDbAccess)

	: CPsdAgentSMBase(aObserver,aDlgPrc,aDbAccess)

/**

Constructor

@param MAgentObserver& aObserver an observer which will be called back to notify changes in the connection

@param CDialogProcessor* aDlgPrc a pointer to a dialog processor object for use by the state machine

@param CCommsDbAccess& aDbAccess a reference to the comm Db access object to allow the state machine to obtain details from CommDb

*/

	{}

CPsdOutSM::~CPsdOutSM()

/**

Destructor

*/

	{}

void CPsdOutSM::ConstructL()

/**

2nd phase construction of the outgoing state machine

creates the initial state of the state machine

*/

	{

	CPsdAgentSMBase::ConstructL();

	iState = new (ELeave) CPsdOutInit(this,this,this);

	}

TCommDbConnectionDirection CPsdOutSM::Direction()

/**

Function indicates the direction of the connection which is in progress

@return TCommDbConnectionDirection the connection direction

*/

	{ return ECommDbConnectionDirectionOutgoing;}

#ifndef INCOMING_NOT_SUPORTED

CPsdInSM* CPsdInSM::NewL(MAgentObserver& aObserver, CDialogProcessor* aDlgPrc, CCommsDbAccess& aDbAccess)

/**

Function creates an inbound connection state machine

@param MAgentObserver& aObserver an observer which will be called back to notify changes in the connection

@param CDialogProcessor* aDlgPrc a pointer to a dialog processor object for use by the state machine

@param CCommsDbAccess& aDbAccess a reference to the comm Db access object to allow the state machine to obtain details from CommDb

@return CPsdInSM* the newly created object (ownership of the object is passed to the function caller)

*/

	{

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

	CPsdInSM* sm = new (ELeave) CPsdInSM(aObserver,aDlgPrc,aDbAccess);

	CleanupStack::PushL(sm);

	sm->ConstructL();

	CleanupStack::Pop();

	return sm;

	}

CPsdInSM::CPsdInSM(MAgentObserver& aObserver, CDialogProcessor* aDlgPrc, CCommsDbAccess& aDbAccess)

	: CPsdAgentSMBase(aObserver,aDlgPrc,aDbAccess)

/**

Constructor

@param MAgentObserver& aObserver an observer which will be called back to notify changes in the connection

@param CDialogProcessor* aDlgPrc a pointer to a dialog processor object for use by the state machine

@param CCommsDbAccess& aDbAccess a reference to the comm Db access object to allow the state machine to obtain details from CommDb

*/

	{}

CPsdInSM::~CPsdInSM()

/**

Destructor

*/

	{}

void CPsdInSM::ConstructL()

/**

2nd phase construction of the incoming state machine

creates the initial state of the state machine

*/

	{

	CPsdAgentSMBase::ConstructL();

	iState = new (ELeave) CPsdInInit(this,this,this);

	}

TCommDbConnectionDirection CPsdInSM::Direction()

/**

Function indicates the direction of the connection which is in progress

@return TCommDbConnectionDirection the connection direction

*/

	{ return ECommDbConnectionDirectionIncoming;}

#endif // #ifndef INCOMING_NOT_SUPORTED

CPsdAgentSMBase::CPsdAgentSMBase(MAgentNotify& aObserver, CDialogProcessor* aDlgPrc, CCommsDbAccess& aDbAccess)

	: CAgentSMBase(aObserver,aDlgPrc,aDbAccess),

		iIsQoSSupported(ETrue)//let's be optimists 

/**

Constructor

*/

	{}

void CPsdAgentSMBase::ConstructL()

/**

2nd phase construction of the state machine base class

to be called in the ConstuctL of derived classes.

The function creates the logging objects and the objects

that contain the parameters for the Context and the QoS

*/

	{

	iEventLogger=CEventLogger::NewL();

	iDataLogger=CDataLogger::NewL(this,this);

	InquireModeL();

	iConfig=CPsdContextConfig::NewL(*iDb,iNetworkMode);

	iQoSConfig=CPsdContextQoSConfig::NewL(*iDb,iNetworkMode);

	}

CPsdAgentSMBase::~CPsdAgentSMBase()

/**

Destructor

*/

	{

	iPacketNetwork.Close();

	iContext.Close();

	iQoS.Close();

	iPhone.Close();

	iTelServer.Close();

	delete iQoSConfig;

	delete iConfig;

	delete iDataLogger;

	delete iEventLogger;

	iEventLogger=0;

	}

TInt CPsdAgentSMBase::GetExcessData(TDes8& /*aBuffer*/)

/**

This is only valid for CSD

To retrieve data for the SM, and accessor functions for the state objects to use.

@param contains data retrieved from the agent for SM.

@return KErrNotSupported if data is not retrieved.

*/

	{

	return KErrNotSupported;

	}

TInt CPsdAgentSMBase::Notification(TNifToAgentEventType /*aEvent*/, TAny* /*aInfo*/)

/**

No NIF to AGENT notifications supported by PSDAGX

Act on / reply to NifMan's notification requests

@param Type of event from Nifman to Agent.

@param Information about the Agent

@return KErrNotSupported if Event type does not exist.

*/

	{

	return KErrNotSupported;

	}

void CPsdAgentSMBase::GetLastError(TInt& aError)

/**

If the context is still open, request last error, otherwise the last error will

have been obtained on closure.

@param error code if the context is not open.

*/

	{

	if (iContext.SubSessionHandle())

		iContext.GetLastErrorCause(aError);

	else

		aError=iErrorCause;

	}

TBool CPsdAgentSMBase::IsIncomingAllowedL() const

/**

Function to allow clients to inquire if incomming connections are allowed

@return ETrue if incomming connections allowed else EFalse

*/

	{

	// Hurricane does not support Incoming connections so hard code this response to False

#ifdef INCOMING_NOT_SUPORTED

	return EFalse;

#else

	// Note - the code below should be used when incoming connections are supported

	TUint32 allowed;

	iDb->GetGlobalL(TPtrC(ACCEPT_INCOMING_GPRS),allowed);

	return (TBool)allowed;

#endif

	}

void CPsdAgentSMBase::GetRemotePartyL(TDes& aRemoteParty) const

/**

Function to allow clients to inquire the name of the remote party in the connection

@param TDes& aRemoteParty reference to a descriptor into which the remote party name will be written.

*/

	{

	iDb->GetDesL(TPtrC(KGeneralServiceTable),TPtrC(COMMDB_NAME),aRemoteParty);

	}

void CPsdAgentSMBase::InquireModeL()

/**

Internal function to figure out the current mode and set the iNetworkMode

member appropriately

*/ 

	{

	TBuf<KCommsDbSvrMaxColumnNameLength> serviceType;

	iDb->GetServiceTypeL(serviceType);

	if(serviceType == TPtrC(OUTGOING_GPRS))

		{

		iNetworkMode = EModeWCDMA;

		}

#ifndef INCOMING_NOT_SUPORTED	

	else if(serviceType == TPtrC(INCOMING_GPRS))

		{

		iNetworkMode = EModeWCDMA;

		}

#endif // #ifndef INCOMING_NOT_SUPORTED	

	else

		{

		// The service type is not supported by this AGX so leave

		User::Leave(KErrNotSupported);

		}

	}

MAgentStateMachineEnv& CPsdAgentSMBase::BaseEnv() 

	{ return *this;}

RTelServer& CPsdAgentSMBase::TelServer() 

	{ return iTelServer;}

RPhone& CPsdAgentSMBase::Phone() 

	{ return iPhone;}

RPacketService& CPsdAgentSMBase::PacketNetwork() 

	{ return iPacketNetwork;}

RPacketContext& CPsdAgentSMBase::Context() 

	{ return iContext;}

TBool CPsdAgentSMBase::IsQoSSupported()const

	{return iIsQoSSupported;}

void CPsdAgentSMBase::SetQoSSupported(TBool isSupported)

	{iIsQoSSupported=isSupported;}

RPacketQoS& CPsdAgentSMBase::QoS()

	{ return iQoS;}

const CPsdContextConfig& CPsdAgentSMBase::Config() const 

	{ return *iConfig;}

const CPsdContextQoSConfig& CPsdAgentSMBase::QoSConfig() const

	{return *iQoSConfig;}

TInt& CPsdAgentSMBase::ErrorCause()

	{ return iErrorCause;}

CEventLogger* CPsdAgentSMBase::Logger() 

	{ return iEventLogger;}

CDataLogger* CPsdAgentSMBase::DataLogger() 

	{ return iDataLogger;}

TBool& CPsdAgentSMBase::AmLogging()  

/**

@deprecated since logging requests are stored in a queue now

*/

	{ return iAmLogging;}

TBool CPsdAgentSMBase::TsyLoaded() const

	{ return iTsyLoaded;}

void CPsdAgentSMBase::SetTsyLoaded(TBool aStatus)

	{ iTsyLoaded=aStatus;}

MPsdEnv::TNetworkMode CPsdAgentSMBase::Mode() const

	{return iNetworkMode;}

CPsdContextConfig* CPsdContextConfig::NewL(CCommsDbAccess& aDbAccess, MPsdEnv::TNetworkMode aMode)

/**

Function creates a CPsdContextConfig object

@param CCommsDbAccess& aDbAccess a reference to the comm Db access object to allow the class to obtain details from CommDb

@param TNetworkMode aMode the mode of the context config parameters to be created.

@return CPsdContextConfig* the newly created object (ownership of the object is passed to the function caller)

*/

	{

	CPsdContextConfig* self = new(ELeave)CPsdContextConfig(aDbAccess,aMode);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); //self

	return self;

	}

CPsdContextConfig::CPsdContextConfig(CCommsDbAccess& aDbAccess, MPsdEnv::TNetworkMode aMode)

: iDbAccess(aDbAccess), iMode(aMode)

	{	

	}

void CPsdContextConfig::ConstructL()

/**

2nd phase construction of CPsdContextConfig calls the appropriate internal construction

function for the current mode

*/

	{

	if(iMode == MPsdEnv::EModeWCDMA)

		{

		GprsConfigConstructL();

		}

	}

CPsdContextConfig::~CPsdContextConfig()

/**

Destructor

*/

	{

	delete iConfig;

	delete iPackedConfig;

	}

const TPacketDataConfigBase& CPsdContextConfig::Config() const

/**

Function that returns the current context config parameters as a TPacketDataConfigBase

@return TPacketDataConfigBase& reference to the config parameters. (reurned as the mode agnostic base class)

*/

	{

	return *iConfig;

	}

TDesC8& CPsdContextConfig::PackedConfig() const

/**

Function that returns the current context config parameters packed in a descriptor

@return TDesC8& reference to the config parameters packed in a descriptor.

*/

	{

	return *iPackedConfig;

	}

TBool CPsdContextConfig::IsConfigSupportedL(const RPacketService& aPacketData, TCommDbConnectionDirection aDirection) const

/**

Inquiry function to enquire if the TSY is able to support the current context parameters

@param RPacketService& aPacketData handle to a previously initialised RPacketService object

@param TCommDbConnectionDirection aDirection the direction of the current connection

@return TBool returns ETrue if config supported, EFalse otherwise.

*/

	{

	if(!iStaticCaps)

		{

		// Only get the caps if they havn't been retrieved before

		User::LeaveIfError(aPacketData.GetStaticCaps(iStaticCaps,iProtocolType));

		}

	TBool result=ETrue;

	if(iMode == MPsdEnv::EModeWCDMA)

		{

		RPacketContext::TContextConfigGPRS& config = *(STATIC_CAST(RPacketContext::TContextConfigGPRS*, iConfig));

		if ( (config.iAnonymousAccessReqd==RPacketContext::ERequired)

			&&(aDirection == ECommDbConnectionDirectionIncoming) )

			{

			result=EFalse;

			}

		else if (!(iStaticCaps & RPacketService::KCapsAASupported)

			&& (config.iAnonymousAccessReqd==RPacketContext::ERequired))

			{

			result=EFalse;

			}

		else if (!(iStaticCaps & RPacketService::KCapsPdpDataCompSupported)

			&& (config.iPdpCompression & RPacketContext::KPdpDataCompression))

			{

			result=EFalse;

			}

		else if (!(iStaticCaps & RPacketService::KCapsPdpHeaderCompSupported)

			&& (config.iPdpCompression & RPacketContext::KPdpHeaderCompression))

			{

			result=EFalse;

			}

		}

	return result;

	}

TBool CPsdContextConfig::TsySupportsDataTransferInfoL(const RPacketService& aPacketData) const

/**

Inquiry function to enquire if the TSY is able to support data transfer inquiries

@param RPacketService& aPacketData handle to a previously initialised RPacketService object

@return TBool returns ETrue if data transfer inquiry supported, EFalse otherwise.

*/

	{

	if(!iStaticCaps)

		{

		// Only get the caps if they havn't been retrieved before

		User::LeaveIfError(aPacketData.GetStaticCaps(iStaticCaps,iProtocolType));

		}

	return(iStaticCaps & RPacketService::KCapsGetDataTransferredSupported);

	}

void CPsdContextConfig::GprsConfigConstructL()

/**

Internal function that constructs the object if the mode is GPRS

interogates CommDb and reads the appropriate parameters from there

Relies on SetCurrentSettingsL() having already been called by the controller

Also expects the service setting to be opened on the correct GPRS Table (outgoing/incoming)

*/

	{

	iConfig=new(ELeave)RPacketContext::TContextConfigGPRS();

	RPacketContext::TContextConfigGPRS& config = *(STATIC_CAST(RPacketContext::TContextConfigGPRS*, iConfig));

	TUint32 pdptype;

	iDbAccess.GetIntL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_PDP_TYPE),pdptype);

	config.iPdpType = (RPacketContext::TProtocolType)pdptype;

	// Save the protocol type seperately for easy access when retreiving static caps

	iProtocolType = config.iPdpType;

	iDbAccess.GetDesL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_APN),config.iAccessPointName);

	iDbAccess.GetDesL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_PDP_ADDRESS),config.iPdpAddress);

	GetGprsCompressionL(config.iPdpCompression);

	GetGprsAAL(config.iAnonymousAccessReqd);

	iPackedConfig = new(ELeave)TPckg<RPacketContext::TContextConfigGPRS>(config);

	}

void CPsdContextConfig::GetGprsCompressionL(TUint& aCompression) const

	{

	aCompression = 0;

	TBool isCompression;

	iDbAccess.GetBoolL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_DATA_COMPRESSION),isCompression);

	if (isCompression)

		{

		aCompression |= RPacketContext::KPdpDataCompression;

		}

	iDbAccess.GetBoolL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_HEADER_COMPRESSION),isCompression);

	if (isCompression)

		{

		aCompression |= RPacketContext::KPdpHeaderCompression;

		}

	}

void CPsdContextConfig::GetGprsAAL(RPacketContext::TAnonymousAccess& aAnonymous) const

	{	

	TBool isAnonymous;

	iDbAccess.GetBoolL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_ANONYMOUS_ACCESS),isAnonymous);

	if (isAnonymous)

		aAnonymous=RPacketContext::ERequired;

	else

		aAnonymous=RPacketContext::ENotRequired;

	}

void CPsdContextConfig::GetGprsEdgeL(TBool& aUseEdge) const

	{	

	TBool isUseEdge;

	iDbAccess.GetBoolL(TPtrC(KGeneralServiceTable),TPtrC(GPRS_USE_EDGE),isUseEdge);

	aUseEdge=isUseEdge;

	}

TBool CPsdContextConfig::QueryIfConfigAcceptable(TDesC8& aNewConfig) const

/**

Function to check if the config passed in the parameter meets the minimum requiremnts

set in CommDb

@param TDesC8& aNewConfig the config to be checked packed in a descriptor

@return TBool ETrue if the config passed in is above or equal to the minimum values, EFalse otherwise.

*/

	{

	TBool ret = ETrue;

	if(iMode == MPsdEnv::EModeWCDMA)

		{

		TPckg<RPacketContext::TContextConfigGPRS> configPckg = *((TPckg<RPacketContext::TContextConfigGPRS>*)&aNewConfig);

		RPacketContext::TContextConfigGPRS& newConfig = configPckg();

		ret = QueryIfGprsConfigAcceptable(newConfig);

		}

	return ret;

	}

TBool CPsdContextConfig::QueryIfGprsConfigAcceptable(const RPacketContext::TContextConfigGPRS& /*aNewConfig*/) const

/**

Internal function to check if the config passed in the parameter meets the minimum required for GPRS