--- /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 <e32cmn.h>
+#include <ssm/ssmstatemanager.h>
+#include <ssm/ssmstateawaresession.h>
+#include <ssm/ssmdomaindefs.h>
+#include <ssm/ssmsubstates.hrh>
+#include <ssm/ssmadaptationcli.h>
+
+#include <ssm/starterclient.h>
+#include <ssm/startupdomainpskeys.h>
+#include <ssm/ssmuiproviderdll.h>
+
+#include <ssm/startupadaptationcommands.h>
+#include <ssm/clayerswp.hrh>
+#include <ssm/ssmsystemwideproperty.h>
+#include <ssm/ssmstates.hrh>
+#include <ssm/ssmpatchableconstants.h>
+
+// 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<TInt>(StartupAdaptation::ESWStateStartingUiServices)
+ - static_cast<TInt>(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;
+ }