diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/src/CSimIncomingContextManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simtsy/src/CSimIncomingContextManager.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,431 @@ +// Copyright (c) 2007-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 "CSimIncomingContextManager.h" + +#include + +#include "SimConstants.h" +#include "Simlog.h" +#include "SimTsy.h" +#include "CSimPhone.h" +#include "csimtimer.h" +#include "CSimPacketService.h" + + +#include "CSimContextHelper.h" + + +CSimIncomingContextManager::CSimIncomingContextManager(CSimPhone* aPhone) : + iPhone(aPhone) + { + + } + +CSimIncomingContextManager::~CSimIncomingContextManager() + { + + delete iForceIncomingContextChange; + + if (iTimer != NULL) + { + iTimer->Cancel(); + delete iTimer; + } + + if (iIncomingContextConfigParams != NULL) + { + iIncomingContextConfigParams->Delete(0, iIncomingContextConfigParams->Count()); + delete iIncomingContextConfigParams; + } + + if (iDelayIncomingContext != NULL) + { + iDelayIncomingContext->Delete(0, iDelayIncomingContext->Count()); + delete iDelayIncomingContext; + } + } + +CSimIncomingContextManager* CSimIncomingContextManager::NewL(CSimPhone* aPhone, CSimPacketService* aSimPacketService) + { + CSimIncomingContextManager* delayIncomingContextManager=new(ELeave) CSimIncomingContextManager(aPhone); + CleanupStack::PushL(delayIncomingContextManager); + delayIncomingContextManager->ConstructL(aSimPacketService); + CleanupStack::Pop(); + return delayIncomingContextManager; + } + + + +void CSimIncomingContextManager::ConstructL(CSimPacketService* aSimPacketService) +/** +* Second phase of the 2-phase constructor. +* Constructs all the member data and retrieves all the data from the config file specific to this class. +* +* @leave Leaves no memory or any data member does not construct for any reason. +*/ + { + LOGPACKET1("CSimIncomingContextManager: Entered ConstructL()"); + + iSimPacketService = aSimPacketService; + + iDelayIncomingContext=new(ELeave) CArrayFixFlat(KMaxNumberofConfigsChanges); + iCurrentDelayIndex=0; + + iTimer=CSimTimer::NewL(iPhone); + + iIncomingContextConfigParams = new (ELeave) CArrayFixFlat(KNumberofConfigs); + + CSimContextHelper::GetContextConfigParamSettingsL( CfgFile(), KSetContextConfigGPRS(), + iIncomingContextConfigParams ); + CSimContextHelper::GetContextConfigParamSettingsL( CfgFile(), KSetContextConfigRel99(), + iIncomingContextConfigParams ); + CSimContextHelper::GetContextConfigParamSettingsL( CfgFile(), KSetContextConfigRel5(), + iIncomingContextConfigParams ); + + iForceIncomingContextChangeProperty=CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimTsyForceIncomingContextActivation, KPSSimTsyForceIncomingContextActivationType); + iForceIncomingContextChange = CSimPubSub::NewL(iSimPacketService, iForceIncomingContextChangeProperty); + iForceIncomingContextChange->Start(); + } + + +/** +* Read in the incomming PDP delay contexts. +* The format of the command is +* DelayIncomingContext = Type , Index, Delay +* Type can be +* TPacketDataConfigBase::KConfigGPRS= 0x01 + +* TPacketDataConfigBase::KConfigRel99Rel4= 0x03 +* TPacketDataConfigBase::KConfigRel5= 0x04 +* +* Index +* This the index for the ContextPDP. +* All the ContextPDP are grouped by type (i.e. GPRS.) +* So +* DelayIncomingContext = 1 , 2, 20 +* points to the PDP context which is GPRS (1), and 2 in the list. +* Delay +* How long before the simulated incoming PDP becomes active. +* +* Stick to general theme of error detection of just make a note and keep going. +* Note only GPRS has been currently tested. +*/ + +void CSimIncomingContextManager::LoadIncomingContextsL( TPtrC8 aTag ) + { + LOGPACKET1("CSimIncomingContextManager: Entered LoadIncomingContextsL()"); + + TDelayIncomingContext incomingContext; + TInt error=KErrNone; + + TInt count = CfgFile()->ItemCount(aTag); + + for(TInt i=0;iItem(aTag,i); + if(!item) + { + error = KErrArgument; + LOGPARSERR("DelayIncomingContext::No parameters in tag",error,0,&aTag); + break; + } + + GetConfigType( (*item), 0, incomingContext.iExtensionId, error ); + if (error) + { + LOGPARSERR("DelayIncomingContext::ConfigType",error,0,&aTag); + } + GetContextIndex( (*item), 1, incomingContext.iIndex, error ); + if (error) + { + LOGPARSERR("DelayIncomingContext::Index",error,0,&aTag); + } + GetDelay( (*item), 2, incomingContext.iDelay, error ); + if (error) + { + LOGPARSERR("DelayIncomingContext::Delay",error,0,&aTag); + } + + iDelayIncomingContext->AppendL(incomingContext); + + } + + LOGMISC2("Finished parsing DelayIncomingContext config parameters...%d items found",count); + } + + +void CSimIncomingContextManager::StartFirstIncomingEvent( ) + { + LOGPACKET1("CSimIncomingContextManager: Entered StartFirstIncomingEvent()" ); + + if(iDelayIncomingContext->Count()!=0) + { + iCurrentDelayIndex = 0; + const TDelayIncomingContext& delayIncomingContext = iDelayIncomingContext->At(0); + LOGPACKET2("CSimIncomingContextManager: Entered StartFirstIncomingEvent() delay = %d", delayIncomingContext.iDelay); + iTimer->Start(delayIncomingContext.iDelay, iSimPacketService, ETimerIdContextActivationRequestedChange); + } + } + + +// This sets up the aPckg according to the current delay index. +// And then sets the index +void CSimIncomingContextManager::NextIncomingEvent( TDes8* aPckg ) + { + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent()" ); + + if (iDelayIncomingContext->Count()==0) + { // We have no incoming events. This is an error. + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent() No events at all!" ); + SimPanic(EGeneral); + return; + } + if(iCurrentDelayIndex >= iDelayIncomingContext->Count()) + { // No more incoming contexts. . + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent() No next event" ); + return; + } + // else we have an incoming context. + + const TDelayIncomingContext* delayIncomingContext = + &(iDelayIncomingContext->At(iCurrentDelayIndex)); + + // Lets deal with the incoming first. + const TContextConfigParam* context = FindContext( iIncomingContextConfigParams, + delayIncomingContext->iExtensionId, delayIncomingContext->iIndex ); + if ( !context ) + { // Unable to find a valid pre allocated context that we can use. + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent() failed unable to identify a valid context." ); + SimPanic(EGeneral); + return ; + } + + if ( GetContextInCorrectFormatForEtel(context, aPckg) ) + { // Okay got data. This will be sent to ETEL to activate the context. + LOGPACKET2("CSimIncomingContextManager: Entered NextIncomingEventt() delay = %d", delayIncomingContext->iDelay); + } + else + { // Error. Unable to format the data. + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent() failed unable format data for choosn context" ); + SimPanic(EGeneral); + return; + } + + // Set up for next event. + if(iCurrentDelayIndex < iDelayIncomingContext->Count()) + { + iCurrentDelayIndex++; + } + + } + + +void CSimIncomingContextManager::Cancel( ) + { + LOGPACKET1("CSimIncomingContextManager::Cancel called"); + iTimer->Cancel(); + } + + +void CSimIncomingContextManager::ForcedIncoming(TInt aIndex, TDes8* aPckg ) + { + LOGPACKET1("CSimIncomingContextManager::ForcedIncoming called"); + + if(iDelayIncomingContext->Count()<=aIndex ) + { + LOGPACKET1("CSimIncomingContextManager::ForcedIncoming invalid context"); + return; + } + // else we have a valid incoming context. + + const TDelayIncomingContext* delayIncomingContext = + &(iDelayIncomingContext->At(aIndex)); + // Note we will do use (type, index) to detmine which context to use. + // We would have difficultly with pdp context index, as they grouped by type. + // This is consistant with how we do it for timers. + + const TContextConfigParam* context = FindContext( iIncomingContextConfigParams, + delayIncomingContext->iExtensionId, delayIncomingContext->iIndex ); + + if ( !context ) + { // Unable to find a valid pre allocated context that we can use. + LOGPACKET1("CSimIncomingContextManager::ForcedIncoming invalid type, index leading to invalid context"); + SimPanic(EGeneral); + return ; + } + + if ( GetContextInCorrectFormatForEtel(context, aPckg) ) + { // Okay got data. This will be sent to ETEL to activate the context. + } + else + { // Error. Unable to format the data. + LOGPACKET1("CSimIncomingContextManager: Entered NextIncomingEvent() failed unable format data for choosn context" ); + SimPanic(EGeneral); + return; + } + + iTimer->Cancel(); + // No more timer. + + } + +TBool CSimIncomingContextManager::IsForcedIncoming(const CSimPubSub::TPubSubProperty aProperty ) + { + TBool ret = (aProperty == iForceIncomingContextChangeProperty); + return ret; + } + + +void CSimIncomingContextManager::GetConfigType( const CTestConfigItem& aItem , + TInt aIndex, TInt& aType, TInt& aError ) + { + + aError = KErrNone; + aType = TPacketDataConfigBase::KConfigGPRS; + // Have a default value even if error. + + + TInt ret=CTestConfig::GetElement(aItem.Value(),KStdDelimiter,aIndex,aType); + if(ret!=KErrNone) + { + aError=KErrArgument; + } + else + { + if ( (1 <= aType) && ( aType <= TPacketDataConfigBase::KConfigRel5 ) ) + { //Okay we have a valid type. + } + else + { // Else not one of the recognised types. + aError=KErrOverflow; + } + } + } + + + +void CSimIncomingContextManager::GetContextIndex( const CTestConfigItem& aItem, + TInt aIndex, TInt& aContextIndex, TInt& aError ) + { + + aError = KErrNone; + aContextIndex = 0; + + TInt ret=CTestConfig::GetElement(aItem.Value(),KStdDelimiter,aIndex,aContextIndex); + if(ret!=KErrNone) + { + aError=KErrArgument; + } + } + + + +void CSimIncomingContextManager::GetDelay( const CTestConfigItem& aItem, + TInt aIndex, TInt& aDelay, TInt& aError ) + { + + aError = KErrNone; + aDelay = 1; + + TInt ret=CTestConfig::GetElement(aItem.Value(),KStdDelimiter,aIndex,aDelay); + if(ret!=KErrNone) + { + aError=KErrArgument; + } + + } + + + +const TContextConfigParam* CSimIncomingContextManager::FindContext( const CArrayFixFlat* aIncomingContextConfigParams, + const TInt aExtensionId, const TInt aIndex ) + { + __ASSERT_ALWAYS(aIncomingContextConfigParams, SimPanic(EIllegalNullPtrParameter)); + + const TContextConfigParam* ret=NULL; + TInt incomingConfigIndex=0; + + for(TInt index=0; index < aIncomingContextConfigParams->Count(); index++) + { + const TContextConfigParam& thisConfig = aIncomingContextConfigParams->At(index); + + if ( thisConfig.iProtocolType == aExtensionId ) + { + if ( aIndex==incomingConfigIndex ) + { // We have found the context. + ret=&(thisConfig); + break; + } + + incomingConfigIndex++; + // Only gets incremented for aExtensionId ids we are looking for. + } + } + // if ret = 0 then we could not find the context. + // This may or may not be an error, depending on usage. + + return ret; + } + + + +TBool CSimIncomingContextManager::GetContextInCorrectFormatForEtel(const TContextConfigParam* aContextConfig, + TDes8* aData) + { + + if (!aContextConfig) + { // Has no context. + return EFalse; + } + else if (aContextConfig->iProtocolType == TPacketDataConfigBase::KConfigGPRS) + { + TPckg& contextConfigGPRSPckg = *( (TPckg*)aData ); + RPacketContext::TContextConfigGPRS& contextConfigGPRS = (contextConfigGPRSPckg)(); + CSimContextHelper::ConvertConfigParams( (*aContextConfig), contextConfigGPRS ); + return ETrue; + } + + #if 0 // Note some may be in a totally different table. + else if (aContextConfig->iProtocolType == TPacketDataConfigBase::KConfigRel99Rel4) + { + + //ConvertConfigParams(const TContextConfigParam& aInput, RPacketContext::TContextConfigGPRS& aOutput); + return ETrue; + } + else if (aContextConfig->iProtocolType == TPacketDataConfigBase::KConfigRel5) + { + + //ConvertConfigParams(const TContextConfigParam& aInput, RPacketContext::TContextConfigGPRS& aOutput); + return ETrue; + } + #endif + + return EFalse; + } + + + + +/** + * Returns a pointer to the current configuration file section. + * + * @return CTestConfigSection A pointer to the current configuration file section. + */ +const CTestConfigSection* CSimIncomingContextManager::CfgFile() + { + return iPhone->CfgFile(); + } +