diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstateplugins/gsapolicy/src/gsastatepolicyfail.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstateplugins/gsapolicy/src/gsastatepolicyfail.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,226 @@ +// 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 +#include +#include + +#include +#include +#include + +#include "gsastatepolicyfail.h" +#include "ssmdebug.h" +#include "ssmpanic.h" + +/** +Panic used by Fail policy plug-in when resource reader is invalid. +Strings must not be longer than 16 characters or they will be truncated by User::Panic() +*/ +_LIT(KPanicGsaFailState, "FailStatePolicy"); + +/** + Fail state policy resource file path. "z:/private//fail/" +*/ +_LIT(KCommandListPath, "z:\\private\\2000D75B\\fail\\"); + +/** +Used to create an instance of MSsmStatePolicy class. + +@return A pointer to an instance of MSsmStatePolicy +*/ +EXPORT_C MSsmStatePolicy* CGsaStatePolicyFail::NewL() + { + CGsaStatePolicyFail* self = new (ELeave) CGsaStatePolicyFail; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + /** +default CTOR +*/ +CGsaStatePolicyFail::CGsaStatePolicyFail() + { + } + +/** +DTOR +*/ +CGsaStatePolicyFail::~CGsaStatePolicyFail() + { + delete iCommandListResourceReader; + iFs.Close(); + } + +/** +Makes a RFs connection. +Creates Command list path and the resource reader. + +@leave One of the error value returned by RFs::Connect() or NewL() +@see RFs::Connect() +*/ +void CGsaStatePolicyFail::ConstructL() + { + User::LeaveIfError(iFs.Connect()); + + // create resource reader + iCommandListResourceReader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath(), *this); + } + +/** +Initializes command list resource reader. + +@param aStatus to complete when the initialization operation has finished + +@panic EInvalidResourceReader if the command list resource reader is invalid + +@see MSsmStatePolicy::Initialize +*/ +void CGsaStatePolicyFail::Initialize(TRequestStatus& aStatus) + { + __ASSERT_DEBUG(iCommandListResourceReader, PanicNow(KPanicGsaFailState, EInvalidResourceReader)); + + // initialise command list resource reader. + iCommandListResourceReader->Initialise(aStatus); + } + +/** +Cancels an asynchronous Initialize operation. + +@see MSsmStatePolicy::InitializeCancel +*/ +void CGsaStatePolicyFail::InitializeCancel() + { + iCommandListResourceReader->InitialiseCancel(); + } + +/** +Deletes all resources and frees itself. + +@see MSsmStatePolicy::Release +*/ +void CGsaStatePolicyFail::Release() + { + delete this; + } + +/** +No transition is allowed from Fail state. Requests for transition to any state is returned as ENotAllowed. + +@param aRequest Contains information about the new request +@param aCurrent Contains NULL or the first accepted but not yet completed transition request +@param aQueued Contains NULL or a second accepted but not yet started transition request +@param aMessage Message sent by SSM server + +@return always ENotAllowed +@see MSsmStatePolicy::TransitionAllowed +*/ +MSsmStatePolicy::TResponse CGsaStatePolicyFail::TransitionAllowed(const TSsmStateTransition& /*aRequest*/, TSsmStateTransition const* /*aCurrent*/, + TSsmStateTransition const* /*aQueued*/, const RMessagePtr2& /*aMessage*/) + { + return ENotAllowed; + } + +/** +Create the command list associated with a sub state transition. + +@param aState Contains the state and substate that identifies the command list to create +@param aReason Contains the reason as given by the request +@param aStatus to complete when the operation has finished +@panic EInvalidResourceReader if the command list resource reader is invalid +@see MSsmStatePolicy::PrepareCommandList +*/ +void CGsaStatePolicyFail::PrepareCommandList(TSsmState aState, TInt /*aReason*/, TRequestStatus& aStatus) + { + __ASSERT_DEBUG( iCommandListResourceReader , PanicNow(KPanicGsaFailState, EInvalidResourceReader)); + + //Let's start from the beginning if no specific sub state is selected + const TUint16 substate = aState.SubState(); + const TSsmState state(aState.MainState(), (substate==KSsmAnySubState) ? ESsmFailSubStateRestart : substate); + const TInt commandListId = state.SubState(); + + //Build the commandlist from resource + iCommandListResourceReader->PrepareCommandList(commandListId, state, aStatus); + } //lint !e1746 Suppress parameter 'aState' could be made const reference + +/** +Cancels asynchronous PrepareCommandList operation. + +@see MSsmStatePolicy::PrepareCommandListCancel +*/ +void CGsaStatePolicyFail::PrepareCommandListCancel() + { + iCommandListResourceReader->PrepareCommandListCancel(); + } + +/** +Return the command list once the PrepareCommandList has completed. +Ownership of the returned command list is transferred to the caller. +@panic EInvalidResourceReader if the command list resource reader is invalid +@return The command list created during the preceding PrepareCommandList step +*/ +CSsmCommandList* CGsaStatePolicyFail::CommandList() + { + __ASSERT_DEBUG( iCommandListResourceReader , PanicNow(KPanicGsaFailState, EInvalidResourceReader)); + + return iCommandListResourceReader->GetCommandList(); + } + +/** +Determines the next sub state transition. +Will never reach GetNextState() if transition to Fail is sucessful as the device would be shutdown/restarted. +Only case when GetNextState is executed is due to a failure in executing Fail transition. +This would cause a panic and thereby causing a device restart. + +@param aCurrentTransition Contains the last executed state +@param aReason Contains the reason as given by the request +@param aError Contains the completion code from the last executed sub-state transition +@param aSeverity Contains the severity of the failed command in case the sub-state transition ended with an error +@param aNextState The next System State to head for, if there is one +@panic EInvalidFailState if the main state is not Fail +@panic ERestartDevice if the value returned by CLE is null +@return ETrue if aNextState contains another System State to head for, or + EFalse if there is no further transitions to do. +@see MSsmStatePolicy::GetNextState +*/ +TBool CGsaStatePolicyFail::GetNextState(TSsmState aCurrentTransition, TInt /*aReason*/, TInt aError, TInt /*aSeverity*/, TSsmState& /*aNextState*/) + { + DEBUGPRINT2(_L("Fail Policy : CLE returned completion code : %d after executing the Fail command list."), aError); + __ASSERT_ALWAYS(aCurrentTransition.MainState() == ESsmFail, PanicNow(KPanicGsaFailState, EInvalidFailState)); + __ASSERT_ALWAYS((KErrNone == aError), PanicNow(KPanicGsaFailState, ERestartDevice)); + + + return EFalse; // no more substates to execute + + } //lint !e1746 Suppress parameter 'aCurrentTransition' could be made const reference + +/** +Callback used by CSsmCommandListResourceReader when a decision needs to be made +on whether to include a command in a command list or not. + +@param aResourceFile Instance of CResourceFile +@param aResourceId Resource id of SSM_SYMBIAN_CONDITIONAL_INFORMATION struct for command +@return ETrue in case the command needs to be included in command list, else EFalse. + +@see MSsmConditionalCallback::ConditionalCommandAllowedL +*/ +TBool CGsaStatePolicyFail::ConditionalCommandAllowedL(CResourceFile& /*aResourceFile*/, TInt /*aResourceId*/) + { + // no commands use 'conditional_information' in Fail state command list. + PanicNow(KPanicGsaFailState, EConditionalInfoNotImplemented); + return EFalse; // keeping compiler happy + }