profilesapplication/Profiles/ProfileApp/SettingsViewSrc/CProfileSettingsContainer.cpp
/*
* Copyright (c) 2002 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: Container class of settings view.
*
*/
// CLASS HEADER
#include "CProfileSettingsContainer.h"
// INTERNAL INCLUDES
#include "CProfileEngineHandler.h"
#include "CProfileIndexHandler.h"
#include "CProfileTabHandler.h"
#include "ProfileSettingsView.hrh"
#include "CProfile3dSettingItem.h"
#include "CProfileFeedbackSettingItem.h"
#include "CProfileVibraSettingItem.h"
#include "CProfilePlayingVolumeSettingItem.h"
#include "CProfileNameSettingItem.h"
#include "CProfileKeypadVolumeSettingItem.h"
#include "CProfileFileListSettingItem.h"
#include "CProfileAlertForSettingItem.h"
#include "CProfileStruct.h"
#include "MProfilesLocalFeatures.h"
#include "ProfilesVariant.hrh" // KProEngFeatureIdVTRingingTone
#include "CProfileSettingsView.h"
#include "MProfileViewHandler.h"
#include "ProfilesDebug.h"
// EXTERNAL INCLUDES
#include <AknDef.h>
#include <aknview.h>
#include <akntitle.h>
#include <akntextsettingpage.h>
#include <aknsoundsystem.h>
#include <eikapp.h>
#include <csxhelp/mode.hlp.hrh>
#include <featmgr.h>
#include <MProfileExtended.h>
#include <MProfileTones.h>
#include <MProfile3DToneSettings.h>
#include <MProfileFeedbackSettings.h>
#include <MProfileExtraSettings.h>
#include <MProfileEngineExtended.h>
#include <MProfilesNamesArray.h>
#include <MProfileName.h>
#include <CProfileChangeNotifyHandler.h>
#include <profilesettingsview.rsg>
#include <data_caging_path_literals.hrh>
#include <centralrepository.h>
#include <settingsinternalcrkeys.h>
#include <bautils.h> // For BaflUtils
#include <StringLoader.h> // For StringLoader
#include <ProfileEngineSDKCRKeys.h> // For KCRUidProfileEngine
#include <ProfileEngineInternalCRKeys.h> // For KProEngDefaultRingingTone
#include <AknQueryDialog.h> // For CAknQueryDialog
#include "CProfileNaviPaneContainer.h" // For CProfileNaviPaneContainer
#include <aknnotewrappers.h> // For CAknInformationNote
// for power save mode handling
#include <psmsettings.h>
#include <psmsrvdomaincrkeys.h>
#include <e32property.h>
#include <ProfileEnginePrivatePSKeys.h>
#include <TProfileToneSettings.h>
namespace
{
// CONSTANTS
const TUid KUidProfileApp = { 0x100058F8 }; // UID of the application
const TInt KVoIPOFF = 0;
const TInt KFileCheckDelay = 100000; // microseconds
const TInt KFileCheckInterval = 5000000;
_LIT( KSettingsViewResourceFileName, "z:PROFILESETTINGSVIEW.RSC" );
}
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::CProfileSettingsContainer
// C++ constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CProfileSettingsContainer::CProfileSettingsContainer(
MProfileViewHandler& aProfileViewHandler,
CProfileEngineHandler& aEngineHandler,
MProfileExternalSettingsHandler& aExternalSettingsHandler,
CProfileIndexHandler* aIndexHandler,
CProfileTabHandler* aTabHandler,
CAknTitlePane* aTitlePane )
:
iResourceLoader( *iCoeEnv ),
iProfileViewHandler( aProfileViewHandler ),
iEngineHandler( aEngineHandler ),
iExternalSettingsHandler( aExternalSettingsHandler ),
iIndexHandler( aIndexHandler ),
iTabHandler( aTabHandler ),
iTitlePane( aTitlePane ),
iAlternateLineService( EFalse )
{
SetMopParent( &( iProfileViewHandler.View() ) );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::ConstructL( const TRect& aRect,
TInt aResourceId )
{
iFs = new ( ELeave ) RFs;
User::LeaveIfError( iFs->Connect() );
PRODEBUG1( "CProfileSettingsContainer ConstructL(%d)",aResourceId );
if( iIndexHandler )
{
iIndexHandler->CreateIndexArrayL();
}
iCopyProfile = CProfileStruct::NewL();
iLocalFeatures = &( iEngineHandler.Engine()->LocalFeatures() );
// Read settings of currently selected profile
ReadProfileL();
// Read alternate line service setting and register as observer
if( iSSSettings.Open() == KErrNone )
{
iSSSettings.Register( ESSSettingsAls, *this ); // ignore return value
TInt als( ESSSettingsAlsNotSupported );
iSSSettings.Get( ESSSettingsAls, als ); // ignore return value
if( als != ESSSettingsAlsNotSupported )
{
iAlternateLineService = ETrue;
}
}
// CRepository session for TTS ringingtone
iTTSSession = CRepository::NewL( KCRUidProfilesLV );
iDefaultTone = new( ELeave ) TFileName();
iSession = CRepository::NewL(KCRUidProfileEngine);
User::LeaveIfError( iSession->Get( KProEngDefaultRingingTone, *iDefaultTone ) );
TInt VoIPSupported( 0 );
iVoIPVariation = CRepository::NewL( KCRUidTelephonySettings );
iVoIPVariation->Get( KDynamicVoIP, VoIPSupported );
iVoIPVariationNotifier = CCenRepNotifyHandler::NewL( *this, *iVoIPVariation,
CCenRepNotifyHandler::EIntKey, KDynamicVoIP );
iVoIPVariationNotifier->StartListeningL();
iVoIPStatus = KVoIPOFF != VoIPSupported;
iKeySounds = static_cast< CAknAppUi* > ( iEikonEnv->AppUi() )->KeySounds();
TParse* fp = new(ELeave) TParse();
fp->Set(KSettingsViewResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);
TFileName resourceFileName( fp->FullName() );
delete fp;
iResourceLoader.OpenL( resourceFileName );
// Construct the setting items
CAknSettingItemList::ConstructFromResourceL( aResourceId );
// Hide all items that must be hidden
SetHiddenFlagsL();
if( iIndexHandler )
{
iIndexHandler->SetListBox( ListBox() );
}
if( iTabHandler )
{
iTabHandler->SetTabObserver( this );
}
else
{
// If the iTabHandler is NULL, set the navi label text to
// the name of current profile.
iNaviPaneContainer = CProfileNaviPaneContainer::NewL(
*( iAvkonAppUi->StatusPane() ), iEngineHandler );
MProfilesNamesArray* nameArray = iEngineHandler.IdArray();
if( iIndexHandler )
{
iNaviPaneContainer->SetNaviPaneTextL(
nameArray->MdcaPoint( iIndexHandler->CurrentProfileIndex() ) );
}
}
iNotifier = CProfileChangeNotifyHandler::NewL( this );
iExternalSettingsHandler.SetObserver( *this );
SetRect( aRect );
ActivateL();
PRODEBUG1( "CProfileSettingsContainer ConstructL(%d) return",aResourceId );
//CheckFileExistenceL();
// If CheckFileExistenceL is called directly from
// ConstructL, DoActivateL in ProfileApp::CProfileSettingsView will be
// blocked while the notes are displayed, causing problems.
// This timer will trigger only once (after 100 ms). After
// that it will be destroyed.
iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
iPeriodic->Start(KFileCheckDelay,
KFileCheckInterval,
TCallBack( CProfileSettingsContainer::StartFileCheckL, this )
);
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::NewL
// Two-phased constructor. Note, this constructor is DEPRECATED and will return
// only NULL if called.
// -----------------------------------------------------------------------------
//
EXPORT_C CProfileSettingsContainer* CProfileSettingsContainer::NewL(
CAknView& /* aAknView */,
CProfileEngineHandler& /* aEngineHandler */,
CProfileIndexHandler* /* aIndexHandler */,
CProfileTabHandler* /* aTabHandler */,
CAknTitlePane* /* aTitlePane */ )
{
return NULL;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CProfileSettingsContainer* CProfileSettingsContainer::NewL(
MProfileViewHandler& aProfileViewHandler,
CProfileEngineHandler& aEngineHandler,
MProfileExternalSettingsHandler& aExternalSettingsHandler,
CProfileIndexHandler* aIndexHandler,
CProfileTabHandler* aTabHandler,
CAknTitlePane* aTitlePane )
{
return CProfileSettingsContainer::NewL( aProfileViewHandler, aEngineHandler,
aExternalSettingsHandler, aIndexHandler, aTabHandler, aTitlePane,
R_PROFILE_SETTING_ITEM_LIST );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CProfileSettingsContainer* CProfileSettingsContainer::NewL(
MProfileViewHandler& aProfileViewHandler,
CProfileEngineHandler& aEngineHandler,
MProfileExternalSettingsHandler& aExternalSettingsHandler,
CProfileIndexHandler* aIndexHandler,
CProfileTabHandler* aTabHandler,
CAknTitlePane* aTitlePane,
TInt aResourceId )
{
CProfileSettingsContainer* self = new( ELeave ) CProfileSettingsContainer(
aProfileViewHandler, aEngineHandler, aExternalSettingsHandler,
aIndexHandler, aTabHandler, aTitlePane );
CleanupStack::PushL( self );
self->ConstructL( aProfileViewHandler.View().ClientRect(), aResourceId );
CleanupStack::Pop( self );
return self;
}
// Destructor.
CProfileSettingsContainer::~CProfileSettingsContainer()
{
if( iPeriodic )
{
iPeriodic->Cancel();
delete iPeriodic;
}
if( iFs )
{
iFs->Close();
}
delete iFs;
PRODEBUG( "~CProfileSettingsContainer begin" );
delete iNotifier;
PRODEBUG( "~CProfileSettingsContainer 2" );
if( iTabHandler )
{
iTabHandler->SetTabObserver( NULL );
}
PRODEBUG( "~CProfileSettingsContainer 3" );
if( iIndexHandler )
{
iIndexHandler->SetListBox( NULL );
}
PRODEBUG( "~CProfileSettingsContainer 4" );
iResourceLoader.Close();
PRODEBUG( "~CProfileSettingsContainer 5" );
ReleaseProfile();
PRODEBUG( "~CProfileSettingsContainer 6" );
delete iCopyProfile;
PRODEBUG( "~CProfileSettingsContainer 7" );
if ( iVoIPVariationNotifier )
{
iVoIPVariationNotifier->StopListening();
delete iVoIPVariationNotifier;
}
if ( iVoIPVariation )
{
delete iVoIPVariation;
}
delete iTTSSession;
delete iSession;
delete iDefaultTone;
PRODEBUG( "~CProfileSettingsContainer 8" );
iSSSettings.Close();
PRODEBUG( "~CProfileSettingsContainer end" );
delete iNaviPaneContainer;
}
// ------------------------------------------------------------------------------
// CProfileSettingsContainer::StartFileCheckL
// ------------------------------------------------------------------------------
//
TInt CProfileSettingsContainer::StartFileCheckL( TAny* aObj )
{
static_cast<CProfileSettingsContainer*>(aObj)->DoFileCheckL();
return 1;
}
// ------------------------------------------------------------------------------
// CProfileSettingsContainer::DoFileCheckL
// ------------------------------------------------------------------------------
//
void CProfileSettingsContainer::DoFileCheckL()
{
if( iPeriodic )
{
iPeriodic->Cancel();
delete iPeriodic;
iPeriodic = NULL;
}
CheckFileExistenceL();
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::AllowedToChange
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CProfileSettingsContainer::AllowedToChange(
TInt aSettingItemId ) const
{
TUint32 flags( iProfile->ModifiableFlags() );
switch( aSettingItemId )
{
// Fall through: If ringing tone is not allowed to change, then none of
// these setting items are allowed to change.
case EProfileSettingRingingToneId:
case EProfileSettingRingingToneLine1Id:
case EProfileSettingRingingToneLine2Id:
{
TInt profileId( 0 );
// Get id of the edited profile
profileId=iProfile->ProfileName().Id();
if( profileId == EProfileOffLineId )
{
// VOIP Changes: WLAN can be enabled also in off-line profile
TBool featuresSupported(
FeatureManager::FeatureSupported(KFeatureIdCommonVoip)
&&
FeatureManager::FeatureSupported(KFeatureIdProtocolWlan)
);
return ( ( flags & EProfileFlagRingingTone ) &&
featuresSupported && iVoIPStatus );
}
else
{
return flags & EProfileFlagRingingTone;
}
}
case EProfileSettingVideoCallToneId:
{
return flags & EProfileFlagVideoCallRingingTone;
}
case EProfileSettingRingingTypeId:
{
return flags & EProfileFlagRingingType;
}
case EProfileSettingRingingVolumeId:
{
return flags & EProfileFlagRingingVolume;
}
case EProfileSettingMediaVolumeId:
{
return flags & EProfileFlagMediaVolume;
}
case EProfileSettingMessageAlertToneId:
{
return flags & EProfileFlagMessageAlertTone;
}
case EProfileSettingEmailAlertToneId:
{
return flags & EProfileFlagEmailAlertTone;
}
case EProfileSettingVibratingAlertId:
{
return flags & EProfileFlagVibratingAlert;
}
case EProfileSettingEmailVibratingAlertId:
{
return flags & EProfileFlagVibratingAlert;
}
case EProfileSettingKeypadVolumeId:
{
return flags & EProfileFlagKeypadVolume;
}
case EProfileSettingWarningAndGameTonesId:
{
return flags & EProfileFlagWarningTones;
}
case EProfileSettingTTSRingingToneId:
{
return flags & EProfileFlagTextToSpeechTone;
}
case EProfileSettingAlertForId:
{
return flags & EProfileFlagAlertFor;
}
case EProfileSettingProfileNameId:
{
return flags & EProfileFlagProfileName;
}
case EProfileSettingPTTRingingToneId:
{
return flags & EProfileFlagPttTone;
}
case EProfileSettingPTTStatusId:
{
return flags & EProfileFlagPttStatus;
}
case EProfileSettingTactileFeedbackId:
{
return flags & EProfileFlagTactileFeedback;
}
case EProfileSettingAudioFeedbackId:
{
return flags & EProfileFlagAudioFeedback;
}
case EProfileSetting3dEffectId:
{
return flags & EProfileFlag3DEffect;
}
case EProfileSetting3dEchoId:
{
return flags & EProfileFlag3DEcho;
}
default:
{
return iExternalSettingsHandler.AllowedToChange( aSettingItemId );
}
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::ReleaseProfile
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::ReleaseProfile()
{
if( iProfile )
{
iProfile->Release();
iProfile = NULL;
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::ReadProfileL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::ReadProfileL()
{
TInt profileId( KErrNotFound );
if( iIndexHandler )
{
// Index handler is set, get id of the edited profile
profileId = iEngineHandler.IdForIndex(
iIndexHandler->CurrentProfileIndex() );
}
else
{
// Index handler is not set.
profileId = User::LeaveIfError(
iEngineHandler.Engine()->ActiveProfileId() );
}
MProfileExtended* profile = iEngineHandler.Engine()->ProfileLC( profileId );
iCopyProfile->LoadL( profile );
CleanupStack::Pop(); // profile
ReleaseProfile(); // delete old iProfile
iProfile = profile;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::SetHiddenFlagsL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::SetHiddenFlagsL()
{
CAknSettingItemArray* array = SettingItemArray();
TUint32 flags( iProfile->VisibleFlags() );
TInt profileId( 0 );
const MProfileTones& tones = iProfile->ProfileTones();
const TProfileToneSettings& toneSettings = tones.ToneSettings();
TBool hide3DEcho = EFalse;
TInt effect = iProfile->ProfileExtraSettings().Profile3DToneSettings().Effect();
if ( effect == EProfile3DEffectOff || effect == EProfile3DEffectStereoWidening )
{
hide3DEcho = ETrue;
}
// Get id of the edited profile
profileId=iProfile->ProfileName().Id();
if( profileId == EProfileOffLineId )
{
TBool featuresSupported(
FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) &&
FeatureManager::FeatureSupported( KFeatureIdProtocolWlan) );
SetItemHidden( EProfileSettingRingingToneId, array,
( iAlternateLineService ) || ( ( ~flags & EProfileFlagRingingTone )
|| !featuresSupported || !iVoIPStatus ) );
SetItemHidden( EProfileSettingRingingToneLine1Id, array,
( !iAlternateLineService ) || ( ( ~flags & EProfileFlagRingingTone )
|| !featuresSupported || !iVoIPStatus ) );
SetItemHidden( EProfileSettingRingingToneLine2Id, array,
( !iAlternateLineService ) || ( ( ~flags & EProfileFlagRingingTone )
|| !featuresSupported || !iVoIPStatus ) );
SetItemHidden( EProfileSetting3dEffectId, array,
!( ( FeatureManager::FeatureSupported( KFeatureId3DRingingTones ) ) &&
( flags & EProfileFlag3DEffect ) && featuresSupported ) );
SetItemHidden( EProfileSetting3dEchoId, array,
!( ( FeatureManager::FeatureSupported( KFeatureId3DRingingTones ) ) &&
( flags & EProfileFlag3DEcho ) && featuresSupported ) );
}
else
{
SetItemHidden( EProfileSettingRingingToneId, array,
( iAlternateLineService ) || ( ~flags & EProfileFlagRingingTone ) );
SetItemHidden( EProfileSettingRingingToneLine1Id, array,
( !iAlternateLineService ) || ( ~flags & EProfileFlagRingingTone ) );
SetItemHidden( EProfileSettingRingingToneLine2Id, array,
( !iAlternateLineService ) || ( ~flags & EProfileFlagRingingTone ) );
SetItemHidden( EProfileSetting3dEffectId, array,
!( ( FeatureManager::FeatureSupported( KFeatureId3DRingingTones ) ) &&
( flags & EProfileFlag3DEffect ) ) );
SetItemHidden( EProfileSetting3dEchoId, array,
!( ( FeatureManager::FeatureSupported( KFeatureId3DRingingTones ) ) &&
( flags & EProfileFlag3DEcho ) ) );
}
if ( hide3DEcho )
{
SetItemHidden( EProfileSetting3dEchoId, array, ETrue );
}
SetItemHidden( EProfileSettingVideoCallToneId, array,
!( ( iLocalFeatures->IsFeatureSupported(
KProEngFeatureIdVTRingingTone ) ) &&
( flags & EProfileFlagVideoCallRingingTone ) &&
FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) ) );
SetItemHidden( EProfileSettingMessageAlertToneId, array,
~flags & EProfileFlagMessageAlertTone );
SetItemHidden( EProfileSettingEmailAlertToneId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdAlwaysOnLineEmail ) ) &&
( flags & EProfileFlagEmailAlertTone ) ) );
SetItemHidden( EProfileSettingRingingTypeId, array,
~flags & EProfileFlagRingingType );
SetItemHidden( EProfileSettingRingingVolumeId, array,
~flags & EProfileFlagRingingVolume );
SetItemHidden( EProfileSettingMediaVolumeId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) ) &&
( flags & EProfileFlagMediaVolume ) ) );
SetItemHidden( EProfileSettingVibratingAlertId, array,
~flags & EProfileFlagVibratingAlert );
if(!iCopyProfile->iVibratingAlert)
{
SetItemHidden( EProfileSettingEmailVibratingAlertId, array,ETrue );
}
else
{
SetItemHidden( EProfileSettingEmailVibratingAlertId, array,EFalse );
}
SetItemHidden( EProfileSettingKeypadVolumeId, array,
~flags & EProfileFlagKeypadVolume );
SetItemHidden( EProfileSettingWarningAndGameTonesId, array,
~flags & EProfileFlagWarningTones );
// Check if TTS ringingtone is supported
TBool textToSpeech( EFalse );
User::LeaveIfError( iTTSSession->Get( KProfilesLVFlags, textToSpeech ) );
textToSpeech &= KProEngFeatureIdTTSRingingTone;
SetItemHidden( EProfileSettingTTSRingingToneId, array,
!( textToSpeech && ( flags & EProfileFlagTextToSpeechTone ) ) );
SetItemHidden( EProfileSettingAlertForId, array,
~flags & EProfileFlagAlertFor );
SetItemHidden( EProfileSettingProfileNameId, array,
~flags & EProfileFlagProfileName );
SetItemHidden( EProfileSettingPTTRingingToneId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdOmaPoc ) ) &&
( flags & EProfileFlagPttTone ) ) );
SetItemHidden( EProfileSettingPTTStatusId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdOmaPoc ) ) &&
( flags & EProfileFlagPttStatus ) ) );
SetItemHidden( EProfileSettingTactileFeedbackId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdTactileFeedback ) ) &&
( flags & EProfileFlagTactileFeedback ) ) );
SetItemHidden( EProfileSettingAudioFeedbackId, array,
!( ( FeatureManager::FeatureSupported( KFeatureIdTactileFeedback ) ) &&
( flags & EProfileFlagAudioFeedback ) ) );
// Check if SilentMode is supported
TBool silentMode(
iLocalFeatures->IsFeatureSupported( KProEngFeatureIdForceSilentMode ) );
if( ( silentMode ) && ( profileId == EProfileSilentId ) )
{
SetItemHidden( EProfileSettingRingingToneId, array, ETrue );
SetItemHidden( EProfileSettingRingingToneLine1Id, array, ETrue );
SetItemHidden( EProfileSettingRingingToneLine2Id, array, ETrue );
SetItemHidden( EProfileSettingVideoCallToneId, array, ETrue );
SetItemHidden( EProfileSettingTTSRingingToneId, array, ETrue );
SetItemHidden( EProfileSettingRingingTypeId, array, ETrue );
SetItemHidden( EProfileSettingRingingVolumeId, array, ETrue );
SetItemHidden( EProfileSettingMessageAlertToneId, array, ETrue );
SetItemHidden( EProfileSettingEmailAlertToneId, array, ETrue );
SetItemHidden( EProfileSettingKeypadVolumeId, array, ETrue );
SetItemHidden( EProfileSettingWarningAndGameTonesId, array, ETrue );
SetItemHidden( EProfileSettingPTTRingingToneId, array, ETrue );
SetItemHidden( EProfileSettingProfileNameId, array, ETrue );
SetItemHidden( EProfileSettingAudioFeedbackId, array, ETrue );
SetItemHidden( EProfileSetting3dEffectId, array, ETrue );
SetItemHidden( EProfileSetting3dEchoId, array, ETrue );
}
iExternalSettingsHandler.SetHiddenItems( *array );
if( iIndexHandler )
{
iIndexHandler->LoadIndices();
}
HandleChangeInItemArrayOrVisibilityL();
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::UpdateSettingsL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::UpdateSettingsL( TBool aReadProfileSettings )
{
// Set listbox invicible to avoid flicker
CEikListBox* listBox = ListBox();
listBox->MakeVisible( EFalse );
// Leavable function calls must be trapped in order to set listbox
// back to visible again if a leave occurs
TRAPD( error,
if( aReadProfileSettings )
{
ReadProfileL();
}
LoadSettingsL(); // from CAknSettingItemList
SetHiddenFlagsL();
);
if( aReadProfileSettings && iIndexHandler )
{
// Set focus back on correct index
iIndexHandler->LoadIndices();
}
// Set listbox back to visible
listBox->MakeVisible( ETrue );
// Now proceed with the leave if one occured
User::LeaveIfError( error );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::EditItemL
// -----------------------------------------------------------------------------
//
EXPORT_C void CProfileSettingsContainer::EditItemL( TInt aIndex, TBool aCalledFromMenu )
{
PRODEBUG1( "CProfileSettingsContainer EditItemL(%d) begin",aIndex );
// Prevent opening of several setting items
if( iItemEdited )
{
return;
}
CAknSettingItem* item = SettingItemArray()->At( aIndex );
TInt identifier( item->Identifier() );
if ( PowerSaveMode( identifier ) )
{
HBufC* buf = StringLoader::LoadLC( R_PROFILE_TEXT_PSM_INFONOTE );
CAknInformationNote* queryDialog = new (ELeave) CAknInformationNote( ETrue );
queryDialog->ExecuteLD( *buf );
CleanupStack::PopAndDestroy( buf );
return;
}
if( !AllowedToChange( identifier ) )
{
// If a setting is not allowed to change, "swallow" list box event.
return;
}
HBufC* titleText = NULL;
if( ( identifier != EProfileSettingRingingToneId ) &&
( identifier != EProfileSettingRingingToneLine1Id ) &&
( identifier != EProfileSettingRingingToneLine2Id ) &&
( identifier != EProfileSettingVideoCallToneId ) &&
( identifier != EProfileSettingMessageAlertToneId ) &&
( identifier != EProfileSettingEmailAlertToneId ) &&
( identifier != EProfileSettingPTTRingingToneId ) )
{
if( aCalledFromMenu ||
!( identifier == EProfileSettingVibratingAlertId ||
identifier == EProfileSettingEmailVibratingAlertId ||
identifier == EProfileSettingWarningAndGameTonesId ||
identifier == EProfileSettingTTSRingingToneId ) )
{
// Set profile name as title pane text.
// Tone selections launch a pop-up, so title pane is not changed.
// Binary pop-up setting item with two available values does not
// launch a setting page when not called from menu so title pane
// is not changed.
if( iTitlePane )
{
titleText = iTitlePane->Text()->AllocLC();
SetTitlePaneTextL( iCopyProfile->iTitleName );
}
}
}
TInt threeDEffect = iCopyProfile->i3DEffect;
if( identifier == EProfileSetting3dEffectId && iIndexHandler )
{
iIndexHandler->StoreIndices();
}
TInt vibratingAlert = iCopyProfile->iVibratingAlert;
if( identifier == EProfileSettingVibratingAlertId && iIndexHandler )
{
iIndexHandler->StoreIndices();
}
// Set boolean value to ETrue that we know that the settings container
// is in editing mode.
iItemEdited = ETrue;
// Store currently active profile id
TInt activeProfileId( iEngineHandler.Engine()->ActiveProfileId() );
// Trap to set boolean value back to EFalse after EditItemL finalized.
PRODEBUG1( "CProfileSettingsContainer EditItemL before list::EditItemL(%d)",aIndex );
TRAPD( error, CAknSettingItemList::EditItemL( aIndex, aCalledFromMenu ) );
PRODEBUG1( "CProfileSettingsContainer EditItemL after list::EditItemL(),error=%d",error );
iItemEdited = EFalse;
User::LeaveIfError( error );
// We don't know whether user cancelled or oked the setting so we must
// store the data from setting item to the modified profile (iCopyProfile).
item->StoreL();
// Compare the settings of the modified profile
// to the settings currently in Profile Engine.
if( !iCopyProfile->CompareL( iProfile ) )
{
// Handle removing of DRM automated content
iCopyProfile->RemoveAutomatedContentL( iProfile );
// Something has changed. Store settings of modified profile.
iCopyProfile->StoreL( iProfile );
// Trap saving of the profile. If for example flash memory runs out
// we can still revert the UI to its previous state.
TRAP( error, iEngineHandler.Engine()->CommitChangeL( *iProfile ) );
if( error != KErrNone || PowerSaveMode() )
{
// An User::Leave occurred. Try to read old settings to memory.
ReadProfileL();
// Update setting item so UI is left to correct state.
item->LoadL();
item->UpdateListBoxTextL();
}
else if( identifier == EProfileSettingProfileNameId )
{
// Profile name was changed.
UpdateProfileNamesL();
}
if ( threeDEffect != iCopyProfile->i3DEffect )
{
UpdateSettingsL( EFalse ); // hide 3DEcho if 3DEffect is off
}
if ( vibratingAlert != iCopyProfile->iVibratingAlert )
{
UpdateSettingsL( EFalse ); //hide emailVibrating alert if vibrating alert is off
}
}
// If the setting is an external (= only in Tones View):
iExternalSettingsHandler.StoreIfChangedL( identifier );
if( titleText )
{
// Set title pane text back
SetTitlePaneTextL( *titleText );
CleanupStack::PopAndDestroy( titleText );
}
// Compare active profile to previously active profile
TInt newActiveProfileId( iEngineHandler.Engine()->ActiveProfileId() );
if( activeProfileId != newActiveProfileId )
{
// Active profile has changed while editing. Update UI.
HandleActiveProfileEventL( EProfileNewActiveProfile, newActiveProfileId );
}
User::LeaveIfError( error );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::CreateSettingItemL
// -----------------------------------------------------------------------------
//
CAknSettingItem* CProfileSettingsContainer::CreateSettingItemL(
TInt aIdentifier )
{
PRODEBUG1( "CProfileSettingsContainer CreateSettingsItemL(%d)",aIdentifier );
CAknSettingItem* settingItem = NULL;
switch( aIdentifier )
{
// Flow through: Ringing tone and RT line 1 are stored to the same
// variable because they can not exist at the same time.
case EProfileSettingRingingToneId:
case EProfileSettingRingingToneLine1Id:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iRingingTone, aIdentifier );
break;
}
case EProfileSettingRingingToneLine2Id:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iRingingToneLine2, aIdentifier );
break;
}
case EProfileSettingVideoCallToneId:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iVideoCallTone, aIdentifier );
break;
}
case EProfileSettingMessageAlertToneId:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iMessageAlertTone, aIdentifier );
break;
}
case EProfileSettingEmailAlertToneId:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iEmailAlertTone, aIdentifier );
break;
}
case EProfileSettingRingingTypeId:
{
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->iRingingType );
break;
}
case EProfileSettingRingingVolumeId:
{
settingItem = new( ELeave ) CProfilePlayingVolumeSettingItem(
aIdentifier, iCopyProfile->iRingingVolume,
*iCopyProfile->iRingingTone,
iCopyProfile->iRingingType,
iCopyProfile->iVibratingAlert,
EFalse ); //Display confirmation note for maximum volume
break;
}
case EProfileSettingMediaVolumeId:
{
settingItem = new( ELeave ) CProfilePlayingVolumeSettingItem(
aIdentifier, iCopyProfile->iMediaVolume,
*iCopyProfile->iRingingTone,
iCopyProfile->iRingingType,
iCopyProfile->iVibratingAlert,
EFalse ); //Do not display confirmation note for maximum volume
break;
}
case EProfileSettingVibratingAlertId:
{
settingItem = new( ELeave ) CAknBinaryPopupSettingItem(
aIdentifier, iCopyProfile->iVibratingAlert );
break;
}
case EProfileSettingEmailVibratingAlertId:
{
settingItem = new( ELeave ) CAknBinaryPopupSettingItem(
aIdentifier, iCopyProfile->iEmailVibratingAlert );
break;
}
case EProfileSettingKeypadVolumeId:
{
settingItem = new( ELeave ) CProfileKeypadVolumeSettingItem(
aIdentifier, iCopyProfile->iKeypadVolume, iKeySounds );
break;
}
case EProfileSettingWarningAndGameTonesId:
{
settingItem = new( ELeave ) CAknBinaryPopupSettingItem(
aIdentifier, iCopyProfile->iWarningAndGameTones );
break;
}
case EProfileSettingAlertForId:
{
settingItem = new( ELeave ) CProfileAlertForSettingItem(
aIdentifier, iCopyProfile->iContactList, iCoeEnv );
break;
}
case EProfileSettingProfileNameId:
{
settingItem = new( ELeave ) CProfileNameSettingItem(
aIdentifier, iCopyProfile->iProfileName, iEngineHandler );
break;
}
case EProfileSettingTTSRingingToneId:
{
settingItem = new( ELeave ) CAknBinaryPopupSettingItem(
aIdentifier, iCopyProfile->iTextToSpeech );
break;
}
case EProfileSettingPTTRingingToneId:
{
settingItem = CreateFileListSettingItemL(
*iCopyProfile->iPTTRingingTone, aIdentifier );
break;
}
case EProfileSettingPTTStatusId:
{
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->iPTTStatus );
break;
}
case EProfileSettingTactileFeedbackId:
{
/*
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->iTactileFeedback );
*/
settingItem = new( ELeave ) CProfileFeedbackSettingItem(
aIdentifier, iCopyProfile->iTactileFeedback );
break;
}
case EProfileSettingAudioFeedbackId:
{
/*
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->iAudioFeedback );
*/
settingItem = new( ELeave ) CProfileFeedbackSettingItem(
aIdentifier, iCopyProfile->iAudioFeedback );
break;
}
case EProfileSetting3dEffectId:
{
/*
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->i3DEffect );
*/
settingItem = new( ELeave ) CProfile3dSettingItem(
aIdentifier,
iCopyProfile->i3DEffect,
*iCopyProfile->iRingingTone,
iCopyProfile->iRingingType,
iCopyProfile->iVibratingAlert,
iCopyProfile->iRingingVolume,
iCopyProfile->i3DEcho );
break;
}
case EProfileSetting3dEchoId:
{
/*
settingItem = new( ELeave ) CAknEnumeratedTextPopupSettingItem(
aIdentifier, iCopyProfile->i3DEcho );
*/
settingItem = new( ELeave ) CProfile3dSettingItem(
aIdentifier,
iCopyProfile->i3DEcho,
*iCopyProfile->iRingingTone,
iCopyProfile->iRingingType,
iCopyProfile->iVibratingAlert,
iCopyProfile->iRingingVolume,
iCopyProfile->i3DEffect );
break;
}
default:
{
PRODEBUG1( "CProfileSettingsContainer before extShandler::CreateSI(%d)",aIdentifier );
settingItem = iExternalSettingsHandler.CreateSettingItemL( aIdentifier );
PRODEBUG( "CProfileSettingsContainer after extShandler::CreateSI" );
break;
}
}
PRODEBUG1( "CProfileSettingsContainer CreateSettingsItemL(%d) before return",aIdentifier );
return settingItem;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::CheckFileExistenceL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::CheckFileExistenceL()
{
CAknSettingItemArray* array = SettingItemArray();
if( !IsItemHidden( EProfileSettingRingingToneId, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iRingingTone ) )
{
TParsePtrC tone( *iCopyProfile->iRingingTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingRingingToneLine1Id, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iRingingTone ) )
{
TParsePtrC tone( *iCopyProfile->iRingingTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingRingingToneLine2Id, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iRingingToneLine2 ) )
{
TParsePtrC tone( *iCopyProfile->iRingingToneLine2 );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingVideoCallToneId, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iVideoCallTone ) )
{
TParsePtrC tone( *iCopyProfile->iVideoCallTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingMessageAlertToneId, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iMessageAlertTone ) )
{
TParsePtrC tone( *iCopyProfile->iMessageAlertTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingEmailAlertToneId, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iEmailAlertTone ) )
{
TParsePtrC tone( *iCopyProfile->iEmailAlertTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
if( !IsItemHidden( EProfileSettingPTTRingingToneId, array ) )
{
if( !BaflUtils::FileExists( *iFs, *iCopyProfile->iPTTRingingTone ) )
{
TParsePtrC tone( *iCopyProfile->iPTTRingingTone );
HBufC* ringtoneNotFoundText =
StringLoader::LoadLC(
R_PROFILE_CONFIRM_RINGTONE_FOUND, tone.NameAndExt() );
CProfileSettingsContainer::LaunchDialogL( *ringtoneNotFoundText );
CleanupStack::PopAndDestroy( ringtoneNotFoundText );
}
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::LaunchDialogL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::LaunchDialogL( const TDesC& aTitleText )
{
CAknQueryDialog* query = CAknQueryDialog::NewL();
const TInt ret( query->ExecuteLD(
R_PROFILE_CONFIRM_RINGTONE_FOUND_QUERY, aTitleText) );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::CreateFileListSettingItemL
// -----------------------------------------------------------------------------
//
CAknSettingItem* CProfileSettingsContainer::CreateFileListSettingItemL(
TDes& aFileName, TInt aIdentifier )
{
CAknSettingItem* settingItem = new( ELeave ) CProfileFileListSettingItem(
aIdentifier,
aFileName,
iCopyProfile->iRingingType,
iCopyProfile->iRingingVolume,
iCopyProfile->iVibratingAlert,
iCopyProfile->i3DEffect,
iCopyProfile->i3DEcho,
iCoeEnv );
return settingItem;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::IndexForId
// -----------------------------------------------------------------------------
//
TInt CProfileSettingsContainer::IndexForId( TInt aId ) const
{
CAknSettingItemArray* array = SettingItemArray();
TInt count( array->Count() );
for( TInt index( 0 ); index < count; index++ )
{
if( array->At( index )->Identifier() == aId )
{
// Searched ID was found, return index
return index;
}
}
return KErrNotFound;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::SetItemHidden
// Sets an item hidden if an index for the id is found.
// In other words does nothing if feature is not supported.
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::SetItemHidden( TInt aId,
CAknSettingItemArray* aArray, TBool aHidden )
{
TInt index( IndexForId( aId ) );
if( index == KErrNotFound )
{
return;
}
aArray->At( index )->SetHidden( aHidden );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::IsItemHidden
//
// -----------------------------------------------------------------------------
//
TBool CProfileSettingsContainer::IsItemHidden( TInt aId,
CAknSettingItemArray* aArray ) const
{
TInt index( IndexForId( aId ) );
if( index == KErrNotFound )
{
return ETrue;
}
return aArray->At( index )->IsHidden();
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::SetTitlePaneTextL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::SetTitlePaneTextL( const TDesC& aTitle )
{
if( !iTitlePane )
{
return;
}
if( aTitle.Length() > 0 )
{
iTitlePane->SetTextL( aTitle );
}
else
{
iTitlePane->SetTextToDefaultL(); // Application name
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::UpdateProfileNamesL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::UpdateProfileNamesL()
{
if( iIndexHandler )
{
TInt newProfileIndex( iIndexHandler->ReadIdArrayAndUpdateL() );
if( iTabHandler )
{
// Refresh tabs with changed profile names
iTabHandler->RefreshTabsL();
iTabHandler->SetActiveTab( newProfileIndex );
}
else
{
// If the iTabHandler is NULL and the iNaviPaneContainer is not NULL
// Set the text of navi pane to currently personlize profile's name.
if ( iNaviPaneContainer )
{
MProfilesNamesArray* nameArray = iEngineHandler.IdArray();
iNaviPaneContainer->SetNaviPaneTextL(
nameArray->MdcaPoint( newProfileIndex ) );
}
}
}
else
{
// No index handler. Just refresh profile name array.
iEngineHandler.ReadIdArrayL();
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::SizeChanged
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::SizeChanged()
{
CEikListBox* lb = ListBox();
if( lb )
{
lb->SetRect( Rect() ); // Set container's rect to listbox
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::HandleListBoxEventL
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::HandleListBoxEventL(
CEikListBox* aListBox, TListBoxEvent aEventType )
{
if( aEventType == EEventEnterKeyPressed ||
aEventType == EEventItemDoubleClicked )
{
CAknSettingItemArray* array = SettingItemArray();
if( !AllowedToChange( array->At( array->ItemIndexFromVisibleIndex(
ListBox()->CurrentItemIndex() ) )->Identifier() ) )
{
// If a setting is not allowed to change, "swallow" list box event.
return;
}
}
CAknSettingItemList::HandleListBoxEventL( aListBox, aEventType );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::GetHelpContext
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::GetHelpContext( TCoeHelpContext& aContext ) const
{
aContext.iMajor = KUidProfileApp;
if( !iExternalSettingsHandler.GetHelpContext( aContext ) )
{
aContext.iContext = KMODE_HLP_PERSONALISE;
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::PhoneSettingChanged
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::PhoneSettingChanged(
TSSSettingsSetting aSetting, TInt aNewValue )
{
if( aSetting == ESSSettingsAls )
{
iAlternateLineService = ( aNewValue != ESSSettingsAlsNotSupported );
if( iIndexHandler )
{
iIndexHandler->StoreIndices();
}
// error ignored. If not enough memory to refresh the UI,
// don't bother launching an error note.
TRAP_IGNORE( SetHiddenFlagsL() );
if( iIndexHandler )
{
iIndexHandler->LoadIndices();
}
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::TabChangedL
// When a tab changes, this method gets called.
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::TabChangedL( TInt /* aIndex */ )
{
UpdateSettingsL();
CEikListBox* listBox = ListBox();
if( listBox )
{
listBox->UpdateScrollBarsL();
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::HandleActiveProfileEventL
// When active profile changes, this method gets called.
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::HandleActiveProfileEventL(
TProfileEvent /* aProfileEvent */, TInt /* aProfileId */ )
{
/*
if( iItemEdited )
{
// Do not update UI if an item is being edited.
return;
}
*/
UpdateProfileNamesL();
UpdateSettingsL();
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::HandleExternalSettingsChangedL
// When external settings change, this method gets called.
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::HandleExternalSettingsChangedL()
{
UpdateSettingsL( EFalse );
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::HandleResourceChange
// -----------------------------------------------------------------------------
//
void CProfileSettingsContainer::HandleResourceChange( TInt aType )
{
if ( aType == KEikDynamicLayoutVariantSwitch ||
aType == KAknsMessageSkinChange )
{
iProfileViewHandler.UpdateClientRect();
}
CAknSettingItemList::HandleResourceChange( aType );
}
// ----------------------------------------------------
// CProfileSettingsContainer::HandleNotifyInt
// ----------------------------------------------------
//
void CProfileSettingsContainer::HandleNotifyInt(
const TUint32 aID,
const TInt aNewValue )
{
if ( KDynamicVoIP == aID)
{
iVoIPStatus = KVoIPOFF != aNewValue;
}
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::ItemEdited
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CProfileSettingsContainer::ItemEdited() const
{
return iItemEdited;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::PowerSaveMode
//
// -----------------------------------------------------------------------------
//
TBool CProfileSettingsContainer::PowerSaveMode( TInt aSettingId )
{
TInt ret = EFalse;
if ( aSettingId == EProfileSettingVibratingAlertId ||
aSettingId == EProfileSettingKeypadVolumeId ||
aSettingId == EProfileSettingTactileFeedbackId ||
aSettingId == EProfileSettingAudioFeedbackId ||aSettingId == EProfileSettingEmailVibratingAlertId)
{
ret = PowerSaveMode();
}
return ret;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::PowerSaveModeL
//
// -----------------------------------------------------------------------------
//
TBool CProfileSettingsContainer::PowerSaveModeL()
{
if( !FeatureManager::FeatureSupported( KFeatureIdPowerSave ) )
{
return EFalse;
}
TInt psm = EPsmsrvModeNormal;
// KProEngPsmChanged PubSub key is set by GSProfilesPlugin when power save
// mode changes. If the key cannot be read (doesn't exist), PSM hasn't
// changed since the last boot and the mode is read from PSM CenRep.
if( RProperty::Get( KPSUidProfileEngine, KProEngPsmChanged, psm ) != KErrNone )
{
CRepository* cenrep = CRepository::NewLC( KCRUidPowerSaveMode );
User::LeaveIfError( cenrep->Get( KPsmCurrentMode, psm ) );
CleanupStack::PopAndDestroy( cenrep );
}
if ( psm == EPsmsrvModePowerSave )
{
return ETrue;
}
return EFalse;
}
// -----------------------------------------------------------------------------
// CProfileSettingsContainer::PowerSaveMode
//
// -----------------------------------------------------------------------------
//
TBool CProfileSettingsContainer::PowerSaveMode()
{
TBool psm = EFalse;
TRAPD( err, psm = PowerSaveModeL() );
if ( err != KErrNone )
{
return EFalse;
}
return psm;
}
// End of File