Collapse all Symbian^3 Product Developer Library

 

examples/AppFramework/ssmanager/policies/sysstates/dummy_backup_statepolicy.cpp

//
// 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: A dummy back up state policy is provided to demonstrate the utility
// of System State Manager framework.
//

#include <ssm/ssmcommandlist.h>
#include <ssm/ssmcommandlistresourcereader.h>
#include <ssm/ssmsubstates.hrh>
#include "dummy_backup_statepolicy.h"

_LIT(KCommandListPath, "z:\\private\\2000d75b\\ssmaeg\\state_dummy_backup\\");

_LIT(KExamplePolicyPanic,"Dummy Back up State Policy");

EXPORT_C MSsmStatePolicy* CSsmDummyBackUpStatePolicy::NewL()
        {
        CSsmDummyBackUpStatePolicy* self = new (ELeave) CSsmDummyBackUpStatePolicy;
        CleanupStack::PushL(self);
        self->ConstructL();
        CleanupStack::Pop(self);
        return self;
        }

CSsmDummyBackUpStatePolicy::CSsmDummyBackUpStatePolicy()
        {
        }

CSsmDummyBackUpStatePolicy::~CSsmDummyBackUpStatePolicy()
        {
        delete iCommandListResourceReader;
        iFs.Close();
        iCurrentlySupportedTransitions.Close();
        }

void CSsmDummyBackUpStatePolicy::ConstructL()
        {
        User::LeaveIfError(iFs.Connect());
        
        // Add supported transitions from Backup 'ESsmBackupSubState'
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, KSsmAnySubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmFail, KSsmAnySubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, ESsmShutdownSubStateCritical));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmNormal, KSsmAnySubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmRestore, ESsmRestoreSubState));
        // create resource reader
        iCommandListResourceReader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath(), *this);
        }

void CSsmDummyBackUpStatePolicy::Initialize(TRequestStatus& aStatus)
        {
        __ASSERT_ALWAYS(iCommandListResourceReader, User::Panic(KExamplePolicyPanic, EInvalidResourceReader));
        // initialise command list resource reader.
        iCommandListResourceReader->Initialise(aStatus);
        }

void CSsmDummyBackUpStatePolicy::InitializeCancel()
        {
        __ASSERT_ALWAYS(iCommandListResourceReader, User::Panic(KExamplePolicyPanic, EInvalidResourceReader));
        iCommandListResourceReader->InitialiseCancel();
        }

void CSsmDummyBackUpStatePolicy::Release()
        {
        delete this;
        }

MSsmStatePolicy::TResponse CSsmDummyBackUpStatePolicy::TransitionAllowed(const TSsmStateTransition& aRequest, TSsmStateTransition const* aCurrent, TSsmStateTransition const* aQueued, const RMessagePtr2& aMessage)
        {
        TResponse response = ENotAllowed;
        if (!aMessage.HasCapability(ECapabilityPowerMgmt))
                {
                return response;
                }

        //Check if the requested transition is supported from current state
        if (TransitionSupported(aRequest.State()))
                {
                if((NULL == aCurrent) && (NULL == aQueued))
                        {
                        // SsmServer is idle
                        response = EDefinitelyAllowed;
                        }
                else if(aRequest.State().MainState() == ESsmFail || aRequest.State().MainState() == ESsmShutdown)
                        {
                        // Going into failed state will override anything currently ongoing or queued
                        response = EReplaceCurrentClearQueue;
                        }
                }
        return response;
        }
void CSsmDummyBackUpStatePolicy::PrepareCommandList(TSsmState aState, TInt /*aReason*/, TRequestStatus& aStatus)
        {       
        __ASSERT_ALWAYS(iCommandListResourceReader, User::Panic(KExamplePolicyPanic, EInvalidResourceReader));
        //Let's start from the beginning if no specific sub state is selected
        const TUint16 substate = aState.SubState();
        //Build the command list from a resource for this substate
        iCommandListResourceReader->PrepareCommandList(substate, aState, aStatus);
        } 

void CSsmDummyBackUpStatePolicy::PrepareCommandListCancel()
        {
        __ASSERT_ALWAYS(iCommandListResourceReader, User::Panic(KExamplePolicyPanic, EInvalidResourceReader));
        iCommandListResourceReader->PrepareCommandListCancel();
        }

CSsmCommandList* CSsmDummyBackUpStatePolicy::CommandList()
        {
        __ASSERT_ALWAYS(iCommandListResourceReader, User::Panic(KExamplePolicyPanic, EInvalidResourceReader));
        return iCommandListResourceReader->GetCommandList();
        }

TBool CSsmDummyBackUpStatePolicy::GetNextState(TSsmState /*aCurrentTransition*/, TInt /*aReason*/, TInt /*aError*/, TInt /*aSeverity*/, TSsmState& /*aNextState*/)
        {
        return EFalse;
        } 

TBool CSsmDummyBackUpStatePolicy::ConditionalCommandAllowedL(CResourceFile& /*aResourceFile*/, TInt /*aResourceId*/)
        {
        return EFalse; //command list doesn't contains commands which have conditions and hence returning EFalse 
        }

/*
Helper function to check whether a requested transition is supported or not.
@param aRequestedState Requested transition
@return ETrue if transition is supported
                EFalse if transition is not supported
*/
TBool CSsmDummyBackUpStatePolicy::TransitionSupported(const TSsmState& aRequestedState) const
        {
        return (iCurrentlySupportedTransitions.Find(aRequestedState) > KErrNotFound);
        }

---

Copyright ©2010 Nokia Corporation and/or its subsidiary(-ies).
All rights reserved. Unless otherwise stated, these materials are provided under the terms of the Eclipse Public License v1.0.