/*
* Copyright (c) 2007 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: SysAp power save mode controller implementation
*
*/
#include <e32debug.h>
#include <psmclient.h>
#include <psmsettings.h>
#include <centralrepository.h>
#include <settingsinternalcrkeys.h>
#include "sysappsmcontroller.h"
#include "SysAp.hrh"
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CSysApPsmController::CSysApPsmController
// ---------------------------------------------------------------------------
//
CSysApPsmController::CSysApPsmController( MSysApPsmControllerNotifyCallback& aCallback ) :
iCallback( aCallback ),
iPsmClient( NULL ),
iActivePsm( EPsmsrvModeNormal ),
iForcedPartialPsm( EFalse ),
iUiItemId( 0 ),
iNextUiOperation( EFalse ),
iDiscardUiNotes( EFalse ),
iBatteryLowCounter( 0 ),
iChargerConnected( EFalse )
{
}
// ---------------------------------------------------------------------------
// CSysApPsmController::ConstructL
// ---------------------------------------------------------------------------
//
void CSysApPsmController::ConstructL()
{
TRACES( RDebug::Print( _L("CSysApPsmController::ConstructL") ) );
iPsmClient = CPsmClient::NewL( *this );
// request explicitly to be notified if some other client changes power save mode
iPsmClient->RequestPowerSaveModeNotification();
TInt err = iPsmClient->PsmSettings().GetCurrentMode( iActivePsm );
if ( err != KErrNone )
{
iActivePsm = EPsmsrvModeNormal;
}
if ( iActivePsm == EPsmsrvPartialMode )
{
iForcedPartialPsm = ETrue;
}
TRACES( RDebug::Print( _L("CSysApPsmController::ConstructL: err=%d, iActivePsm=%d"), err, iActivePsm ) );
}
// ---------------------------------------------------------------------------
// CSysApPsmController::NewL
// ---------------------------------------------------------------------------
//
CSysApPsmController* CSysApPsmController::NewL( MSysApPsmControllerNotifyCallback& aCallback )
{
CSysApPsmController* self = new( ELeave ) CSysApPsmController( aCallback );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::~CSysApPsmController
// ---------------------------------------------------------------------------
//
CSysApPsmController::~CSysApPsmController()
{
TRACES( RDebug::Print( _L("CSysApPsmController::~CSysApPsmController") ) );
delete iPsmClient;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::SetPowerSaveMode
// ---------------------------------------------------------------------------
//
void CSysApPsmController::SetPowerSaveMode( TInt aNewMode )
{
TRACES( RDebug::Print( _L("CSysApPsmController::SetPowerSaveMode: aNewMode=%d"), aNewMode ) );
iPsmClient->CancelPowerSaveModeNotificationRequest();
iPsmClient->ChangePowerSaveMode( aNewMode );
}
// ---------------------------------------------------------------------------
// CSysApPsmController::FullPsmEnabled
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::FullPsmEnabled() const
{
return iActivePsm == EPsmsrvModePowerSave;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::PartialPsmEnabled
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::PartialPsmEnabled() const
{
return iActivePsm == EPsmsrvPartialMode;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::UiItemId
// ---------------------------------------------------------------------------
//
TInt CSysApPsmController::UiItemId() const
{
return iUiItemId;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::SetUiItemId
// ---------------------------------------------------------------------------
//
void CSysApPsmController::SetUiItemId( TInt aUiItemId )
{
iUiItemId = aUiItemId;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::DoEnablePartialPsm
// ---------------------------------------------------------------------------
//
void CSysApPsmController::DoEnablePartialPsm( TBool aEnable )
{
TRACES( RDebug::Print( _L("CSysApPsmController::DoEnablePartialPsm: aEnable=%d"), aEnable ) );
// full PSM is only controlled by the user so toggling partial PSM is only possible between itself and normal mode
if ( aEnable )
{
// activate only from normal mode
if( iActivePsm == EPsmsrvModeNormal )
{
SetPowerSaveMode( EPsmsrvPartialMode );
iDiscardUiNotes = ETrue; // partial mode errors not reflected to UI
}
}
else
{
// deactivate only from partial mode
if ( iActivePsm == EPsmsrvPartialMode )
{
SetPowerSaveMode( EPsmsrvModeNormal );
iDiscardUiNotes = ETrue; // partial mode errors not reflected to UI
}
}
}
// ---------------------------------------------------------------------------
// CSysApPsmController::BatteryLow
// ---------------------------------------------------------------------------
//
void CSysApPsmController::BatteryLow( TBool aBatteryIsLow )
{
TRACES( RDebug::Print( _L("CSysApPsmController::BatteryLow: aBatteryIsLow=%d"), aBatteryIsLow ) );
if ( aBatteryIsLow )
{
iForcedPartialPsm = ETrue; // when battery is low, at least partial PSM must be active
}
else
{
iForcedPartialPsm = EFalse; // releasing partial PSM when battery is not low
iBatteryLowCounter = 0; // show activation query on next battery low event
}
}
// ---------------------------------------------------------------------------
// CSysApPsmController::ConnectCharger
// ---------------------------------------------------------------------------
//
void CSysApPsmController::ConnectCharger( TBool aConnect )
{
TRACES( RDebug::Print( _L("CSysApPsmController::ConnectCharger: aConnect=%d"), aConnect ) );
BatteryLow( EFalse );
iChargerConnected = aConnect;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::ChargerConnected
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::ChargerConnected() const
{
return iChargerConnected;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::DoEnableFullPsm
// ---------------------------------------------------------------------------
//
void CSysApPsmController::DoEnableFullPsm( TBool aEnable )
{
TRACES( RDebug::Print( _L("CSysApPsmController::DoEnableFullPsm: aEnable=%d, iActivePsm=%d, iForcedPartialPsm=%d"),
aEnable, iActivePsm, iForcedPartialPsm ) );
if ( aEnable && iActivePsm != EPsmsrvModePowerSave )
{
SetPowerSaveMode( EPsmsrvModePowerSave );
}
else if ( !aEnable && iActivePsm != EPsmsrvModeNormal )
{
SetPowerSaveMode( EPsmsrvModeNormal );
}
}
// ---------------------------------------------------------------------------
// CCSysApPsmController::SetNextUiOperation
// ---------------------------------------------------------------------------
//
void CSysApPsmController::SetNextUiOperation( TBool aIsActivate )
{
TRACES( RDebug::Print( _L("CSysApPsmController::SetNextUiOperation: aIsActivate=%d"), aIsActivate ) );
iNextUiOperation = aIsActivate;
}
// ---------------------------------------------------------------------------
// CCSysApPsmController::NextUiOperation
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::NextUiOperation() const
{
return iNextUiOperation;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::PowerSaveModeChanged
// from MPsmClientObserver
// ---------------------------------------------------------------------------
//
void CSysApPsmController::PowerSaveModeChanged( const TPsmsrvMode aMode )
{
TRACES( RDebug::Print( _L("CSysApPsmController::PowerSaveModeChanged: iActivePsm=%d, aMode=%d, iForcedPartialPsm"),
iActivePsm, aMode, iForcedPartialPsm ) );
iPsmClient->RequestPowerSaveModeNotification(); // must be requested after every completion
iActivePsm = aMode;
TBool showUiNotes = !iDiscardUiNotes;
iDiscardUiNotes = EFalse; // set now because if partial PSM is activated it sets this back to ETrue
switch ( iActivePsm )
{
case EPsmsrvModeNormal:
if ( showUiNotes )
{
TRAP_IGNORE( iCallback.NotifyPowerSaveModeL( MSysApPsmControllerNotifyCallback::EPsmDeactivationComplete ) );
}
if ( iForcedPartialPsm )
{
DoEnablePartialPsm( ETrue );
}
break;
case EPsmsrvModePowerSave:
if ( showUiNotes )
{
TRAP_IGNORE( iCallback.NotifyPowerSaveModeL( MSysApPsmControllerNotifyCallback::EPsmActivationComplete ) );
}
break;
case EPsmsrvPartialMode: // partial mode not shown in UI level
default:
break;
}
}
// ---------------------------------------------------------------------------
// CSysApPsmController::PowerSaveModeChangeError
// from MPsmClientObserver
// ---------------------------------------------------------------------------
//
void CSysApPsmController::PowerSaveModeChangeError( const TInt aError )
{
TRACES( RDebug::Print( _L("CSysApPsmController::PowerSaveModeChangeError: aError=%d, iDiscardUiNotes=%d"),
aError, iDiscardUiNotes ) );
if ( aError != KErrCancel ) // ignore error if it is due cancellation of notification request
{
if ( aError != KErrServerTerminated ) // new request would cause another completion with this error code (infinitely)
{
iPsmClient->RequestPowerSaveModeNotification(); // must be requested after every completion
}
if ( !iDiscardUiNotes ) // The user is not notified if activating partial mode fails
{
if ( iActivePsm == EPsmsrvModePowerSave )
{
TRAP_IGNORE( iCallback.NotifyPowerSaveModeL( MSysApPsmControllerNotifyCallback::EPsmDeactivationFailed ) );
}
else
{
TRAP_IGNORE( iCallback.NotifyPowerSaveModeL( MSysApPsmControllerNotifyCallback::EPsmActivationFailed ) );
}
}
iDiscardUiNotes = EFalse;
}
}
// ---------------------------------------------------------------------------
// CSysApPsmController::ShowActivateQuery
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::ShowActivateQuery()
{
TBool retVal( EFalse );
// conditions
// power saving is not yet activated
// this is the first battery low warning
if ( iBatteryLowCounter == 0 &&
iActivePsm == EPsmsrvModeNormal )
{
// query must be activated in CenRep setting
retVal = QueriesEnabled();
}
iBatteryLowCounter++; // query must not be shown on subsequent low events
return retVal;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::ShowDeactivateQuery
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::ShowDeactivateQuery() const
{
TBool retVal( EFalse );
// conditions
// power saving has been activated
// query has been activated in CenRep setting
if ( iActivePsm == EPsmsrvModePowerSave )
{
// query must be activated in CenRep setting
retVal = QueriesEnabled();
}
return retVal;
}
// ---------------------------------------------------------------------------
// CSysApPsmController::QueriesEnabled
// ---------------------------------------------------------------------------
//
TBool CSysApPsmController::QueriesEnabled() const
{
TBool enabled( ETrue ); // enabled by default
CRepository* repository( NULL );
TRAPD( err, repository = CRepository::NewL( KCRUidDeviceManagementSettings ) );
if ( err == KErrNone )
{
TInt value( 0 );
err = repository->Get( KSettingsPowerSavingQuery, value );
if ( err == KErrNone )
{
enabled = value ? ETrue : EFalse;
}
}
delete repository;
TRACES( RDebug::Print( _L("CSysApPsmController::QueriesEnabled: enabled=%d, err=%d"), enabled, err ) );
return enabled;
}