// Copyright (c) 2001-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:
//

#include "gprs.h"
#include "Gprscontext.h"
#include "mSLOGGER.H"
#include <pcktcs.h>
#include "AtGprsClass.h"
#include "ATIO.H"
#include <etelpckt.h>
#include "TSYCONFG.H"
#include "NOTIFY.H"
#include "Matstd.h"


/**
 * @file
 * This file implements the CATGprsClass class which is one of the state machine used by the
 * GPRS AT TSY library. 
 * This state machine uses the "AT+CGCLASS" command.
 */

CATGprsClass* CATGprsClass::NewL(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit, CPhoneGlobals* aPhoneGlobals)
/**
 *  Standard 2 phase constructor.
 * @param aIo pointer to communication object.
 * @param aTelObject pointer to parent.
 * @param aInit pointer to AT phone init object.
 * @param aPhoneGlobals pointer to phone global wide states.
 */
	{
	CATGprsClass* p=new(ELeave) CATGprsClass(aIo, aTelObject, aInit, aPhoneGlobals);
	CleanupStack::PushL(p);
	p->ConstructL();
	CleanupStack::Pop();
	return p;
	}

void CATGprsClass::ConstructL()
/**
 * Construct all objects that can leave.
 */
	{
	CATCommands::ConstructL();
	}

CATGprsClass::CATGprsClass(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit, CPhoneGlobals* aPhoneGlobals)
: CATCommands(aIo, aTelObject, aInit, aPhoneGlobals)
/**
 * Constructor.
 * @param aIo pointer to communication object.
 * @param aTelObject pointer to parent.
 * @param aInit pointer to AT phone init object.
 * @param aPhoneGlobals pointer to phone global wide states.
 */
	{
	LOGTEXT(_L8("CATGprsClass::CATGprsClass called"));
	}


CATGprsClass::~CATGprsClass()
/**
 * Destructor.
 */
	{
	LOGTEXT(_L8("CATGprsClass::~CATGprsClass called"));
	iIo->RemoveExpectStrings(this);				
	}

void CATGprsClass::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams)
/**
 * This is the standard entry point for sending class command.
 */
	{
	iClass = REINTERPRET_CAST(RPacketService::TMSClass*, aParams);
	if(MakeupCGCLASS(*iClass) == KErrNotSupported)
		{
		iTelObject->ReqCompleted(aTsyReqHandle, KErrArgument);
		return;
		}
	iReqHandle = aTsyReqHandle;
	iState=ESendClassCommand;
	Write(KGprsCommandTimeOut);	
	}

void CATGprsClass::Stop(TTsyReqHandle aTsyReqHandle)
/**
 */
	{
	LOGTEXT(_L8("CATGprsClass::Stop called"));
	if(iState!=EATNotInProgress && aTsyReqHandle==iReqHandle)
		{
		LOGTEXT(_L8("CATGprsClass::Stop Cancelling client request"));
		Complete(KErrCancel,ETimeOutCompletion);
		}
	}

void CATGprsClass::CompleteWithIOError(TEventSource aSource,TInt aStatus)
/**
 * This Function completes the command from the client with an error.
 * @param aSource source of event from communication class.
 * @param aStatus status of event.
 */
	{
	LOGTEXT(_L8("CATGprsClass::CompleteWithIOError called"));
	Complete(aStatus, aSource);
	}


void CATGprsClass::Complete(TInt aError,TEventSource aSource)
/**
 * This Function completes the command from the client.
 *
 * @param aError an error code to relay to client.
 */
	{
	LOGTEXT2(_L8("CATGprsClass::Complete called error: %d"), aError);
	RemoveStdExpectStrings();
	iIo->WriteAndTimerCancel(this);	
	iIo->RemoveExpectStrings(this);
	if (aError==KErrNone)
		{
		((CGprs*)iTelObject)->SetCurrentMSClass(*iClass);
		}

	// Allow our base class to do its thing and then complete the client request
	CATCommands::Complete(aError,aSource);		
	iTelObject->ReqCompleted(iReqHandle, aError);

	iState=EATNotInProgress;
	}


void CATGprsClass::EventSignal(TEventSource aSource)
/**
 * This function contains the state machine for the command.  The states flow consecutively and are
 * described below.
 * 
 * @par ESendClassCommand
 * Wait for response to the AT+CGCLASS=%S command.
 *
 * @par EClassReadComplete
 * Reads the Modem's response to the AT+CGCLASS=%S command and completes the request.
 *
 */
	{
	if ((aSource==ETimeOutCompletion) )
		{
		LOGTEXT(_L8("CATGprsClass::EventSignal, Timeout"));
		Complete(KErrTimedOut,aSource);
		return;
		}
	switch(iState)
		{
		case ESendClassCommand:
				{
				LOGTEXT(_L8("CATGprsClass::EventSignal, ESendConnectCommand"));
				__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));
				StandardWriteCompletionHandler(aSource, KGprsCommandTimeOut);
				iState = EClassReadComplete;
				}
			break;
		case EClassReadComplete:
				{
				LOGTEXT(_L8("CATGprsClass::EventSignal, EConnectReadComplete"));
				__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));
				TInt ret = ValidateExpectString();
				Complete(ret, aSource);
				}
			break;
		case EATNotInProgress:
			break;
		default:
				{
				LOGTEXT(_L8("CATGprsClass::EventSignal, Default, panic"));
				Panic(EIllegalEvent);
				}
		}		
	}

TInt CATGprsClass::MakeupCGCLASS(RPacketService::TMSClass aClass)
/**
 * This function creates the AT+CGCLASS string to send to the phone.
 * The main task of this function is to populate iTxBuffer.
 * @param aClass MSClass to set.
 */
	{
	_LIT8(KCGClass, "AT+CGCLASS=%S\r");
	switch(aClass)
		{
		case RPacketService::EMSClassDualMode:
			iTxBuffer.Format(KCGClass, &KMSClassA);
			break;
		case RPacketService::EMSClassSuspensionRequired:
			iTxBuffer.Format(KCGClass, &KMSClassB);
			break;
		case RPacketService::EMSClassAlternateMode:
			iTxBuffer.Format(KCGClass, &KMSClassCAlternateMode);
			break;
		case RPacketService::EMSClassPacketSwitchedOnly:
			iTxBuffer.Format(KCGClass, &KMSClassCGPRSOnly);
			break;
		case RPacketService::EMSClassCircuitSwitchedOnly:
			iTxBuffer.Format(KCGClass, &KMSClassCCircuitSwitchedOnly);
			break;
		default:
			return KErrNotSupported;
		}
	return KErrNone;
}