diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatemgr/test/tcmn/src/t_ssmstatemanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstatemgr/test/tcmn/src/t_ssmstatemanager.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,373 @@ +// Copyright (c) 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: Test wrapper for RSsmStateManager +// +// +// + +#include +#include +#include + +#include "t_ssmstatemanager.h" + +_LIT(KMainState, "mainState"); +_LIT(KSubState, "subState"); +_LIT(KReason, "reason"); +_LIT(KAsync, "async"); + +//commands +_LIT(KCmdNewL, "NewL"); +_LIT(KCmdConnect, "Connect"); +_LIT(KCmdClose, "Close"); +_LIT(KCmdRequestStateTransition, "RequestStateTransition"); +_LIT(KCmdRequestStateTransitionCancel, "RequestStateTransitionCancel"); +_LIT(KCmdDestructor, "~"); + +/** + * Two phase constructor + */ +CTestRSsmStateManager* CTestRSsmStateManager::NewL() + { + CTestRSsmStateManager* testSsmStateManager = new (ELeave) CTestRSsmStateManager(); + CleanupStack::PushL(testSsmStateManager); + testSsmStateManager->ConstructL(); + CleanupStack::Pop(testSsmStateManager); + return testSsmStateManager; + } + +/** + * GetObject + */ +TAny* CTestRSsmStateManager::GetObject() + { + return iSsmStateManager; + } + +/** + * SetObjectL + */ +void CTestRSsmStateManager::SetObjectL(TAny* aAny) + { + DoCleanup(); + iSsmStateManager=static_cast (aAny); + } + +/** + * DisownObjectL + */ +void CTestRSsmStateManager::DisownObjectL() + { + iSsmStateManager = NULL; + } + +/** + * Protected constructor. First phase construction + */ +CTestRSsmStateManager::CTestRSsmStateManager() +:CDataWrapper() + { + } + +/** + * Protected constructor. Second phase construction + */ +void CTestRSsmStateManager::ConstructL() + { + iActiveNotifyOnChange = CActiveCallback::NewL(*this); + } + +/** + * Destructor. + */ +CTestRSsmStateManager::~CTestRSsmStateManager() + { + DoCleanup(); + delete iActiveNotifyOnChange; + } + +/** + * Process a command read from the ini file + * + * @param aCommand the command to process + * @param aSection the entry in the ini file requiring the command to be processed + * + * @return ETrue if the command is processed + */ +TBool CTestRSsmStateManager::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex) + { + TBool retVal = ETrue; + if (aCommand == KCmdNewL) + { + DoCmdNew(); + } + else if (aCommand == KCmdConnect) + { + DoCmdConnect(); + } + else if (aCommand == KCmdRequestStateTransition ) + { + DoCmdRequestStateTransition(aSection, aAsyncErrorIndex); + } + else if (aCommand == KCmdRequestStateTransitionCancel ) + { + DoCmdRequestStateTransitionCancel(); + } + else if (aCommand == KCmdClose) + { + DoCmdClose(); + } + else if (aCommand == KCmdDestructor) + { + DoCmdDestructor(); + } + else + { + retVal = EFalse; + } + + return retVal; + } + +/** + * Creates RSSmStateAwareSession class instance + */ +void CTestRSsmStateManager::DoCmdNew() + { + INFO_PRINTF1(_L("Create RSsmStateManager instance")); + DoCleanup(); + + TRAPD( err, iSsmStateManager = new (ELeave)RSsmStateManager()); + if (err!=KErrNone) + { + ERR_PRINTF2(_L("new error %d"), err); + SetError(err); + } + } + +/** + * Close RSsmStateManager handle + */ +void CTestRSsmStateManager::DoCmdClose() + { + INFO_PRINTF1(_L("Close RSsmStateManager ")); + iSsmStateManager->Close(); + } + +/** + * Contains cleanup implementation + */ +void CTestRSsmStateManager::DoCleanup() + { + if(iSsmStateManager != NULL) + { + INFO_PRINTF1(_L("Deleting current RSsmStateManager")); + delete iSsmStateManager; + iSsmStateManager = NULL; + } + } + +/** + * Destroy RSsmStateManager object + */ +void CTestRSsmStateManager::DoCmdDestructor() + { + INFO_PRINTF1(_L("Destroying the object")); + DoCleanup(); + } + +/** + * Connects to Ssm State Manager + */ +void CTestRSsmStateManager::DoCmdConnect() + { + TInt err = iSsmStateManager->Connect(); + if (KErrNone != err) + { + ERR_PRINTF2(_L("Connect() error %d"), err); + SetError(err); + } + } + +/** + * RequestStateTransition in case of State transition request + */ +void CTestRSsmStateManager::DoCmdRequestStateTransition(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + TPtrC getMainState; + TPtrC getSubStates; + if (!GetStringFromConfig(aSection, KMainState(), getMainState )) + { + //set default value if value is not provided in .ini file + getMainState.Set( _L("ESsmNormal")); + } + if (!GetStringFromConfig(aSection, KSubState(), getSubStates )) + { + //set default value if value is not provided in .ini file + getSubStates.Set(_L("ESsmNormalRfOffSubState")); + } + TUint16 mainState; + TUint16 subState; + if ( MapToMainState( getMainState, mainState )&& MapToSubState( getSubStates, subState )) + { + TInt reason; + if (!GetIntFromConfig(aSection, KReason(), reason )) + { + //set default reason if value is not provided in .ini file + reason = KErrNone; + } + + TSsmStateTransition stateTransition(mainState, subState, reason ); + //Call the API depending on async call or not + TBool async; + if (!GetBoolFromConfig(aSection, KAsync(), async )) + { + async = EFalse; + } + if (async) + { + iSsmStateManager->RequestStateTransition(stateTransition, iActiveNotifyOnChange->iStatus); + iActiveNotifyOnChange->Activate(aAsyncErrorIndex); + IncOutstanding(); + } + else + { + TInt err = iSsmStateManager->RequestStateTransition(stateTransition); + if (err != KErrNone) + { + ERR_PRINTF2(_L("RequestStateTransition() failed with error %d"), err); + SetError(err); + } + } + } + else + { + ERR_PRINTF1(_L(" Mapping state/substate failed%d")); + SetBlockResult(EFail); + } + } + +/** + * RequestStateTransitionCancel + */ +void CTestRSsmStateManager::DoCmdRequestStateTransitionCancel() + { + iSsmStateManager->RequestStateTransitionCancel(); + } + +/** + Virtual RunL - Called on completion of an asynchronous command + @param aActive Active Object that RunL has been called on + @pre N/A + @post N/A + @leave system wide error code + @see MTPActiveCallback +*/ +void CTestRSsmStateManager::RunL(CActive* aActive, TInt aIndex) + { + INFO_PRINTF1(_L("RSsmStateManager->RunL()is called")); + if (aActive == iActiveNotifyOnChange) + { + TInt err=iActiveNotifyOnChange->iStatus.Int(); + if ( err != KErrNone ) + { + ERR_PRINTF2(_L("RunL Error %d"), err); + SetAsyncError(aIndex, err); + } + } + DecOutstanding(); + } + +/** + Virtual DoCancel - Request to cancel the asynchronous command + @param aActive Active Object that DoCancel has been called on + @pre - N/A + @post - N/A + @leave system wide error code + @see MTPActiveCallback +*/ +void CTestRSsmStateManager::DoCancel(CActive* aActive, TInt aIndex) + { + INFO_PRINTF1(_L("DoCancel")); + if( aActive == iActiveNotifyOnChange ) + { + TInt err = iActiveNotifyOnChange->iStatus.Int(); + if (err!=KErrNone) + { + ERR_PRINTF2(_L("DoCancel Error %d"), err); + SetAsyncError(aIndex, err); + } + } + DecOutstanding(); + } +/** + * Helper method to Map defined MainState on ssmstates.hrh + */ +TBool CTestRSsmStateManager::MapToMainState( TPtrC& aGetMainState, TUint16& aMainState ) + { + TInt ret = ETrue; + if(!(aGetMainState.Compare(_L("ESsmStartup")))) + { + aMainState = ESsmStartup; + } + else if(!(aGetMainState.Compare(_L("ESsmNormal")))) + { + aMainState = ESsmNormal; + } + else if(!(aGetMainState.Compare(_L("ESsmShutdown")))) + { + aMainState = ESsmShutdown; + } + else if(!(aGetMainState.Compare(_L("ESsmFail")))) + { + aMainState = ESsmFail; + } + else if(!(aGetMainState.Compare(_L("ESsmRestore")))) + { + aMainState = ESsmRestore; + } + else if(!(aGetMainState.Compare(_L("ESsmEmergencyCallsOnly")))) + { + aMainState = ESsmEmergencyCallsOnly; + } + else + { + ret = EFalse; + } + return ret; + } + +/** + * Helper method to Map defined SubState in ssmsubstates.hrh..Need to be extended for other substates + */ +TBool CTestRSsmStateManager::MapToSubState( TPtrC& aGetSubState, TUint16& aSubState ) + { + TInt ret = ETrue; + if(!(aGetSubState.Compare(_L("ESsmNormalRfOffSubState")))) + { + aSubState = ESsmNormalRfOffSubState; + } + else if(!(aGetSubState.Compare(_L("ESsmNormalSubState")))) + { + aSubState = ESsmNormalSubState; + } + else if(!(aGetSubState.Compare(_L("ESsmNormalRfOnSubState")))) + { + aSubState = ESsmNormalRfOnSubState; + } + else + { + ret = EFalse; + } + return ret; + }