Collapse all Symbian^3 Product Developer Library

 

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

// gsastatepolicynormal.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:
//
// Extends the GSA (Generic Startup Architecture) normal policy to  
// to support the dummy backup and restore states added as part of this example. 
// The default Normal state policy supports only the states start up, shut down, and fail.
// The example uses this extended normal state, which replaces the existing normal policy.
//  
// This example Normal State policy creates and registers a SwP (ssm.swp.policy.dummy.diskstatus.dll)
// with key KExampleSwPKey and KExampleSwPValue.

#include <barsread2.h>
#include <e32debug.h>
#include <ssm/ssmcmd.hrh>
#include <ssm/ssmsubstates.hrh>

#include <ssm/ssmstatetransition.h>
#include <ssm/ssmcommandlistresourcereader.h>

#include "gsastatepolicynormal.h"

_LIT(KPanicGsaNormalState, "NormalStatePolicy");

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

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

void CEgGsaStatePolicyNormal::ConstructL()
        {
        User::LeaveIfError(iFs.Connect());
        
        // Add supported transitions from Normal 'ESsmNormal'
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, KSsmAnySubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmFail, KSsmAnySubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, ESsmShutdownSubStateCritical));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmBackup, ESsmBackupSubState));
        iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmRestore, ESsmRestoreSubState));
        
        /*
    Normal state policy resource file path ("z:\private<SID of SSM>\normal\").
    This resource file is already being generated by the production code, hence its not re-generated.
        */
        _LIT(KCommandListPath, "z:\\private\\2000D75B\\normal\\");
        
        // Create a resource reader
        iCommandListResourceReader = CSsmCommandListResourceReader::NewL(iFs, KCommandListPath(), *this);
        }

void CEgGsaStatePolicyNormal::Initialize(TRequestStatus& aStatus)
        {
        __ASSERT_DEBUG(iCommandListResourceReader, User::Panic(KPanicGsaNormalState, EInvalidResourceReader));

        // initialise command list resource reader.
        iCommandListResourceReader->Initialise(aStatus);
        }

void CEgGsaStatePolicyNormal::InitializeCancel()
        {
        __ASSERT_DEBUG(iCommandListResourceReader, User::Panic(KPanicGsaNormalState, EInvalidResourceReader));
        iCommandListResourceReader->InitialiseCancel();
        }

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

MSsmStatePolicy::TResponse CEgGsaStatePolicyNormal::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 the current state
        if (TransitionSupported(aRequest.State()))
                {
                if((NULL == aCurrent) && (NULL == aQueued))
                        {
                        // SsmServer is idle
                        response = EDefinitelyAllowed;
                        }
                else if(aRequest.State().MainState() == ESsmFail)
                        {
                        // Going into failed state will override anything currently ongoing or queued
                        response = EReplaceCurrentClearQueue;
                        }
                }
        TSsmStateName name = aRequest.State().Name();
        return response;                
        }

void CEgGsaStatePolicyNormal::PrepareCommandList(TSsmState aState, TInt /*aReason*/, TRequestStatus& aStatus)
        {
        __ASSERT_DEBUG( iCommandListResourceReader , User::Panic(KPanicGsaNormalState, EInvalidResourceReader));

        // Start from the beginning if no specific substate is selected
        const TUint16 substate = aState.SubState();
        const TSsmState state(aState.MainState(), (substate==KSsmAnySubState) ? ESsmNormalSubState : substate);
        const TInt commandListId = state.SubState();

        // Build the command list from the resource
        iCommandListResourceReader->PrepareCommandList(commandListId, state, aStatus);
        } 

void CEgGsaStatePolicyNormal::PrepareCommandListCancel()
        {
        iCommandListResourceReader->PrepareCommandListCancel();
        }

CSsmCommandList* CEgGsaStatePolicyNormal::CommandList()
        {
        __ASSERT_DEBUG( iCommandListResourceReader , User::Panic(KPanicGsaNormalState, EInvalidResourceReader));

        return iCommandListResourceReader->GetCommandList();
        }

TBool CEgGsaStatePolicyNormal::GetNextState(TSsmState aCurrentTransition, TInt /*aReason*/, TInt aError, TInt /*aSeverity*/, TSsmState& aNextState)
        {
        __ASSERT_ALWAYS(aCurrentTransition.MainState() == ESsmNormal, User::Panic(KPanicGsaNormalState, EInvalidNormalState));
        if (KErrNone != aError)
                {
                aNextState = TSsmState(ESsmFail, KSsmAnySubState);
                TSsmStateName name = aNextState.Name();
                return ETrue;
                }

        return EFalse;  // no more substates to execute
        } 

TBool CEgGsaStatePolicyNormal::ConditionalCommandAllowedL(CResourceFile& /*aResourceFile*/, TInt /*aResourceId*/)
        {
        // no commands use 'conditional_information' in Normal state command list.
        User::Panic(KPanicGsaNormalState, EConditionalInfoNotImplemented);
        return EFalse;  // avoid a compiler warning.
        }

/*
Helper function to check whether requested transition is supported or not.
@param aRequestedState Requested transition
@return         ETrue if transition is supported
                EFalse if transition is not supported
*/
TBool CEgGsaStatePolicyNormal::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.