diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/multimodetsy/Multimode/gprs/ATGprsClass.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/multimodetsy/Multimode/gprs/ATGprsClass.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,222 @@ +// 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 +#include "AtGprsClass.h" +#include "ATIO.H" +#include +#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; +}