diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatereferenceplugins/clayer/src/starterclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstatereferenceplugins/clayer/src/starterclient.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,427 @@ +// 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 "ssmclayer.h" +#include "ssmdebug.h" +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +// The following assert ensures that it's ok to just copy the handle from the +// RSsmStateManager class as there are no other data members if RSsmStateManage +// is the same size as RSessionBase. +// +// This assert will fail if extra data members are added to RSsmStateManager +// This ensures that the code in RStarterSession is correct. + +__ASSERT_COMPILE(sizeof(RSessionBase) == sizeof(RSsmStateManager)); //lint -e752 Suppress local declarator not referenced + + +EXPORT_C TInt RStarterSession::Connect() + { + RSsmStateManager session; + TInt err = session.Connect(); + if (err == KErrNone) + { + // Connection successful, copy handle from session to this handle + SetHandle(session.Handle()); + } + // session is not closed before returning as this now owns the handle + return err; + } + +/* + * Helper Function that reads KRFStatusPropertyKey SWP using RSsmSystemWideProperty and returns. + * @return KErrNone on Success + * Returns an error code from RSsmSystemWideProperty API - Connect & GetValue. + * On resulting error return, aRFSwpStatus contains ESsmRfOff + * + * @internalComponent +*/ +static TInt GetRFSwpStatus ( TInt& aRFSwpStatus ) + { + TUint rfStatusPropertyKey = CSsmUiSpecific::RFStatusPropertyKey (); + + RSsmSystemWideProperty swp; + TInt err = swp.Connect ( rfStatusPropertyKey ); + DEBUGPRINT2A ( "RF SWP connect error = %d ",err ); + TInt rfStatus ( ESsmRfOff ); + if ( err == KErrNone ) + { + err = swp.GetValue ( rfStatus ); + DEBUGPRINT3A ( "RF SWP status = %d ( err %d )", rfStatus, err ); + } + + aRFSwpStatus = rfStatus; + swp.Close (); + return err; + } + +/** + * This adjustment specifies how to convert start-up sub-states + * to the states defined in StartupAdaptation::TGlobalState + * + * It is calculated using the same method specified in CSaaStateAdaptation::MapToStartupAdaptationState(), + * see that method for further details. + * + * @internalComponent + */ +const TInt KStartupSubStateAdjustment = static_cast(StartupAdaptation::ESWStateStartingUiServices) + - static_cast(ESsmStartupSubStateNonCritical); + +/** + * Helper Function that is used for performing transition to startup substates . + * @return KErrNone on Success and returns an error if RequestStateTransition fails or transition is not supported + * + * @internalComponent +*/ +static TInt TransitionToStartupSubState(TSsmState &aCurrentState, RSsmStateManager& aSession) + { + TInt err = KErrNone; + TInt reason = KSsmCLayerNullReason; + TUint16 mainstate = aCurrentState.MainState(); + TUint16 substate = 0; + + DEBUGPRINT2A( "RStarterSession::SetState, mainstate = %d", mainstate ); + if( mainstate == ESsmStartup) + { + switch(aCurrentState.SubState()) + { + case StartupAdaptation::ESWStateCharging - KStartupSubStateAdjustment: + { + substate = StartupAdaptation::ESWStateChargingToNormal - KStartupSubStateAdjustment; + TSsmStateTransition stateinfo(mainstate, substate, reason); + // Make request for state transition + err = aSession.RequestStateTransition(stateinfo); + break; + } + case StartupAdaptation::ESWStateAlarm - KStartupSubStateAdjustment: + { + substate = StartupAdaptation::ESWStateAlarmToNormal - KStartupSubStateAdjustment; + TSsmStateTransition stateinfo(mainstate, substate, reason); + // Make request for state transition + err = aSession.RequestStateTransition(stateinfo); + break; + } + default: + { + err = KErrArgument; + } + } + } + else + { + err = KErrArgument; + } + return err; + } + +/** + * Helper Function that is used for obtaining the currentstate. + * @return KErrNone on Success and returns an error if RSsmStateAwareSession fails to connect to domainId KSM2UiServicesDomain3 + * @internalComponent +*/ +static TInt GetCurrentState( TSsmState &aCurrentState ) + { + RSsmStateAwareSession sas; + const TInt err = sas.Connect(KSM2UiServicesDomain3); + if (KErrNone == err) + { + aCurrentState = sas.State(); + sas.Close(); + } + return err; + } + +EXPORT_C TInt RStarterSession::SetState( const TGlobalState aState ) + { + RSsmStateManager session; + // Set session to use the handle stored in this + session.SetHandle(Handle()); + + DEBUGPRINT2A( "RStarterSession::SetState( %d )", aState ); + TInt err = KErrNone; + //Initialising main state with an invalid main state (i.e ESsmMainSystemStateMax) + TUint16 mainstate = ESsmMainSystemStateMax; + TUint16 substate = 0; + TSsmState currentState; + TUint rfStatusPropertyKey = CSsmUiSpecific::RFStatusPropertyKey(); + switch (aState) + { + case ENormal: + { + //Switch depending on the patchable constant KSsmGracefulOffline is enabled + if (IsSsmGracefulOffline()) + { + err = GetCurrentState(currentState); + if ( err == KErrNone ) + { + TInt globalSystemState; + err =RProperty::Get(KPSUidStartup, KPSGlobalSystemState, globalSystemState); + if( err == KErrNone ) + { + mainstate = currentState.MainState(); + //Allow state transition to normal RF ON if global state is not ESwStateNormalRfOn + if ((mainstate == ESsmNormal) && (globalSystemState != ESwStateNormalRfOn)) + { + substate = ESsmNormalRfOnSubState; + TInt reason = KSsmCLayerNullReason; + TSsmStateTransition stateinfo(ESsmNormal,substate, reason); + err = session.RequestStateTransition(stateinfo); + } + else + { + //Transition to startup substate + err = TransitionToStartupSubState(currentState, session); + } + } + } + } + else + { + TInt rfSwpValue; + err = GetRFSwpStatus ( rfSwpValue ); + // Change value of RF Swp (to ESsmRfOn) only if it is not ESsmRfOn. + if (err == KErrNone && rfSwpValue != ESsmRfOn) + { + TSsmSwp swpRFStatus ( rfStatusPropertyKey, ESsmRfOn ); + err = session.RequestSwpChange ( swpRFStatus ); + } + else + { + err = GetCurrentState(currentState); + if(err == KErrNone) + { + //Transition to startup substate + err = TransitionToStartupSubState(currentState, session); + } + } + } + break; + } + case EAlarm: + { + // Charging to alarm + mainstate = ESsmStartup; + substate = StartupAdaptation::ESWStateChargingToAlarm - KStartupSubStateAdjustment; + TInt reason = KSsmCLayerNullReason; + TSsmStateTransition stateinfo(mainstate, substate, reason); + // Make request and return success. + err = session.RequestStateTransition(stateinfo); + break; + } + case ECharging: + { + // Alarm to charging + mainstate = ESsmStartup; + substate = StartupAdaptation::ESWStateAlarmToCharging - KStartupSubStateAdjustment; + TInt reason = KSsmCLayerNullReason; + TSsmStateTransition stateinfo(mainstate, substate, reason); + // Make request and return success. + err = session.RequestStateTransition(stateinfo); + break; + } + case EOffline: + { + if (IsSsmGracefulOffline()) + { + TInt globalSystemState; + err =RProperty::Get(KPSUidStartup, KPSGlobalSystemState, globalSystemState); + if( err == KErrNone ) + { + //Allow state transition if global state is not ESwStateNormalRfOff + if (globalSystemState != ESwStateNormalRfOff) + { + const TInt reason = KSsmCLayerNullReason; + substate = ESsmNormalRfOffSubState; + TSsmStateTransition stateinfo(ESsmNormal, substate, reason); + // Make request for substate transition to offline + err = session.RequestStateTransition(stateinfo); + } + } + } + else + { + TInt rfSwpValue; + err = GetRFSwpStatus ( rfSwpValue ); + // Change value of RF SwP (to ESsmRfOff) only if it is not ESsmRfOff. + if ( err == KErrNone && rfSwpValue != ESsmRfOff ) + { + TSsmSwp swpRFStatus ( rfStatusPropertyKey, ESsmRfOff ); + err = session.RequestSwpChange ( swpRFStatus ); + } + } + + break; + } + case EBTSap: + { + TInt rfSwpValue; + err = GetRFSwpStatus ( rfSwpValue ); + // Change value of RF Swp (to ESsmBtSap) only if it is notESsmBtSap. + if ( err == KErrNone && rfSwpValue != ESsmBtSap ) + { + TSsmSwp swpRFStatus ( rfStatusPropertyKey, ESsmBtSap ); + err = session.RequestSwpChange ( swpRFStatus ); + } + break; + } + default: + { + err = KErrArgument; + } + } + + // Session is not closed before returning as this owns the handle + return err; + } + +EXPORT_C void RStarterSession::Reset( const TResetReason aReason ) + { + RSsmStateManager session; + // Set session to use the handle stored in this + session.SetHandle(Handle()); + + // Package up the state transition + TUint16 mainstate = ESsmShutdown; + TUint16 substate = KSsmAnySubState; + TInt reason = aReason; + TSsmStateTransition stateinfo(mainstate, substate, reason); + + // Make request and ignore return value + session.RequestStateTransition(stateinfo); + // Session is not closed before returning as this owns the handle + } + +EXPORT_C void RStarterSession::Shutdown() + { + RSsmStateManager session; + // Set session to use the handle stored in this + session.SetHandle(Handle()); + + // Package up the state transition + TUint16 mainstate = ESsmShutdown; + TUint16 substate = KSsmAnySubState; + TInt reason = KSsmCLayerPowerOffReason; // A null reason on shutdown will lead to a poweroff + TSsmStateTransition stateinfo(mainstate, substate, reason); + + // Make request and ignore return value + session.RequestStateTransition(stateinfo); + // Session is not closed before returning as this owns the handle + } + +EXPORT_C TInt RStarterSession::ResetNetwork() + { + RSsmStateManager session; + // Set session to use the handle stored in this + session.SetHandle(Handle()); + + // Make request and return success. + TUint rfStatusPropertyKey = CSsmUiSpecific::RFStatusPropertyKey(); + TSsmSwp swpRFStatus(rfStatusPropertyKey, ESsmRfOff); + + RSsmSystemWideProperty swp; + swp.Connect(rfStatusPropertyKey); + + TRequestStatus status; + //Subscribe for SwP changes + swp.Subscribe(status); + + TInt requestResult= session.RequestSwpChange(swpRFStatus); + if(KErrNone == requestResult) + { + // Wait for SwP Change + User::WaitForRequest(status); + swpRFStatus.Set(rfStatusPropertyKey, ESsmRfOn); + requestResult = session.RequestSwpChange(swpRFStatus); + } + swp.Close(); + // Session is not closed before returning as this owns the handle + return requestResult; + } + +EXPORT_C TBool RStarterSession::IsRTCTimeValid() + { + TBool isRTCValid = EFalse; + + //Ignoring return code for compatability reasons + RProperty::Get(CSsmUiSpecific::ValidateRTCPropertyCategory(), + CSsmUiSpecific::ValidateRTCPropertyKey(), isRTCValid); + return isRTCValid; + } + +EXPORT_C TInt RStarterSession::ActivateRfForEmergencyCall() + { + RSsmEmergencyCallRfAdaptation ecradaptation; + TInt err = ecradaptation.Connect(); + if (err != KErrNone) + { + return err; + } + TRequestStatus status; + // Request activation + ecradaptation.ActivateRfForEmergencyCall(status); + // Wait for completion + User::WaitForRequest(status); + ecradaptation.Close(); + // Return the completion value of status + return status.Int(); + } + +EXPORT_C TInt RStarterSession::DeactivateRfAfterEmergencyCall() + { + RSsmEmergencyCallRfAdaptation ecradaptation; + TInt err = ecradaptation.Connect(); + if (err != KErrNone) + { + return err; + } + TRequestStatus status; + // Request activation + ecradaptation.DeactivateRfForEmergencyCall(status); + // Wait for completion + User::WaitForRequest(status); + ecradaptation.Close(); + // Return the completion value of status + return status.Int(); + } + +EXPORT_C TInt RStarterSession::EndSplashScreen() + { + RProperty splashscreen; + TInt err = splashscreen.Attach(KPSUidStartup, KPSSplashShutdown, EOwnerThread); + if (err != KErrNone) + { + return err; + } + + err = splashscreen.Set(ESplashShutdown); + + splashscreen.Close(); + return err; + }