/*
* Copyright (c) 2005-2010 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: CSysApPubSubObserver implementation
*
*/
// INCLUDES
#include <e32property.h>
#include <sacls.h>
#include <startupdomainpskeys.h>
#include "CoreApplicationUIsPrivatePSKeys.h"
#include <ctsydomainpskeys.h>
#include <wlaninternalpskeys.h>
#include <connect/sbdefs.h>
#include <hwrmpowerstatesdkpskeys.h>
#include "SysApPubSubObserver.h"
#include "SysApSubscriber.h"
#include "SysApAppUi.h"
#include "SysApFeatureManager.h"
#include <ir_sock.h>
#include <NetworkHandlingDomainPSKeys.h>
#include <hwrmdomainpskeys.h>
#include <DataSyncInternalPSKeys.h>
#include <hwrmfmtxdomainpskeys.h>
#include <hwrmfmtx.h>
#include "sysapremconobserver.h"
#include <lbs/locationfwdomainpskeys.h>
#include <smsuaddr.h>
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <ASShdAlarm.h>
#else
#include <asshddefs.h>
#include <ASShdAlarmCal.h>
#include <asshdalarm.h>
#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
// CONSTANTS
const TUint KCoreAppUIsMmcRemovedWithoutEjectCmdMask = 0xFFFF;
const TUint KCoreAppUIsMmcRemovedWithoutEjectValShift = 16;
// ============================ MEMBER FUNCTIONS ==============================
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::NewL()
// ----------------------------------------------------------------------------
CSysApPubSubObserver* CSysApPubSubObserver::NewL( CSysApAppUi& aSysApAppUi )
{
CSysApPubSubObserver* self = new(ELeave) CSysApPubSubObserver( aSysApAppUi );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::CSysApPubSubObserver()
// ----------------------------------------------------------------------------
CSysApPubSubObserver::CSysApPubSubObserver( CSysApAppUi& aSysApAppUi ) :
iSysApAppUi( aSysApAppUi ),
iRestoreOngoing( EFalse )
{
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::ConstructL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::ConstructL()
{
// Category KUidSystemCategory
iBatteryBarsSubscriber = CSysApSubscriber::NewL( *this, KPSUidHWRMPowerState, KHWRMBatteryLevel );
iBatteryBarsSubscriber->Subscribe();
iBatteryCStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidHWRMPowerState, KHWRMBatteryStatus );
iBatteryCStatusSubscriber->Subscribe();
iChargerCStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidHWRMPowerState, KHWRMChargingStatus );
iChargerCStatusSubscriber->Subscribe();
iInboxStatusSubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, KUidInboxStatusValue );
iInboxStatusSubscriber->Subscribe();
iOutboxStatusSubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, KUidOutboxStatusValue );
iOutboxStatusSubscriber->Subscribe();
iIrdaStatusSubscriber = CSysApSubscriber::NewL( *this, KIrdaPropertyCategory, KIrdaStatus );
iIrdaStatusSubscriber->Subscribe();
iGprsStatusSubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, KPSUidGprsStatusValue );
iGprsStatusSubscriber->Subscribe();
iWcdmaStatusSubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, KPSUidWcdmaStatusValue );
iWcdmaStatusSubscriber->Subscribe();
iLocationGlobalPrivacySubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, KPSUidLocationGlobalPrivacyValue );
iLocationGlobalPrivacySubscriber->Subscribe();
iRestoreBackupSubscriber = CSysApSubscriber::NewL( *this, KUidSystemCategory, conn::KUidBackupRestoreKey );
iRestoreBackupSubscriber->Subscribe();
// Category KPSUidStartup
iSimChangedSubscriber = CSysApSubscriber::NewL( *this, KPSUidStartup, KPSSimOwned );
iSimChangedSubscriber->Subscribe();
iWakeupAlarmSubscriber = CSysApSubscriber::NewL( *this, KAlarmServerPubSubCategory, KWakeupAlarmPubSubKey );
iWakeupAlarmSubscriber->Subscribe();
// Category KPSUidCoreApplicationUIs
iAlarmLightSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KLightsAlarmLightActive );
iAlarmLightSubscriber->Subscribe();
iVTLightsSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KLightsVTForcedLightsOn );
iVTLightsSubscriber->Subscribe();
iSSLightsSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KLightsSSForcedLightsOn );
iSSLightsSubscriber->Subscribe();
iATCLightsSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KLightsATCForcedLightsOn );
iATCLightsSubscriber->Subscribe();
iLightsControlSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KLightsControl );
iLightsControlSubscriber->Subscribe();
iDisableKeyguardSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsDisableKeyguard );
iDisableKeyguardSubscriber->Subscribe();
iSoftRejectSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsSoftReject );
iSoftRejectSubscriber->Subscribe();
iUipIndSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsUipInd );
iUipIndSubscriber->Subscribe();
iMessageToneQuitSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsMessageToneQuit );
iMessageToneQuitSubscriber->Subscribe();
iNspsRawKeyEventSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsNspsRawKeyEvent );
iNspsRawKeyEventSubscriber->Subscribe();
iLightsRawKeyEventSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsLightsRawKeyEvent );
iLightsRawKeyEventSubscriber->Subscribe();
iMmcRemovedWithoutEjectSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsMmcRemovedWithoutEject );
iMmcRemovedWithoutEjectSubscriber->Subscribe();
iNewEmailStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsNewEmailStatus );
iNewEmailStatusSubscriber->Subscribe();
iAutolockStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus );
iAutolockStatusSubscriber->Subscribe();
iPoCIndicatorSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsPoCIndicator );
iPoCIndicatorSubscriber->Subscribe();
iPoCMissedIndicatorSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsPoCMissedIndicator );
iPoCMissedIndicatorSubscriber->Subscribe();
iTarmStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator );
iTarmStatusSubscriber->Subscribe();
iMtvRecStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsMtvRecStatus );
iMtvRecStatusSubscriber->Subscribe();
iMtvDvbhStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsMtvDvbhStatus );
iMtvDvbhStatusSubscriber->Subscribe();
// Category KPSUidWlan
iWlanIndicatorSubscriber = CSysApSubscriber::NewL( *this, KPSUidWlan, KPSWlanIndicator );
iWlanIndicatorSubscriber->Subscribe();
// KPSUidCtsyCallInformation
iCallInfoSubscriber = CSysApSubscriber::NewL( *this, KPSUidCtsyCallInformation, KCTsyCallState );
iCallInfoSubscriber->Subscribe();
// Category KPSUidNetworkInfo
iHomeZoneStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidNetworkInfo, KNWHomeZoneStatus );
iHomeZoneStatusSubscriber->Subscribe();
iNetworkModeSubscriber = CSysApSubscriber::NewL( *this, KPSUidNetworkInfo, KNWTelephonyNetworkMode );
iNetworkModeSubscriber->Subscribe();
// Category KPSUidHWRM
iFlipStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidHWRM, KHWRMFlipStatus );
iFlipStatusSubscriber->Subscribe();
if ( iSysApAppUi.SysApFeatureManager().FmTxSupported() )
{
// Category KHWRMFmTxStatus
iFmTxStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidHWRMFmTx, KHWRMFmTxStatus );
iFmTxStatusSubscriber->Subscribe();
iPreviousFmTxPSValue = EFmTxStateUnknown;
}
iSyncStatusSubscriber = CSysApSubscriber::NewL( *this, KPSUidDataSynchronizationInternalKeys, KDataSyncStatus );
iSyncStatusSubscriber->Subscribe();
iVideoSharingIndicatorSubscriber = CSysApSubscriber::NewL( *this, KPSUidCoreApplicationUIs, KCoreAppUIsVideoSharingIndicator );
iVideoSharingIndicatorSubscriber->Subscribe();
iGpsIndicatorSubscriber = CSysApSubscriber::NewL( *this, KPosIndicatorCategoryUid, KPosIntGpsHwStatus );
iGpsIndicatorSubscriber->Subscribe();
iSmsPhoneStoreSubscriber = CSysApSubscriber::NewL( *this, KUidPSSMSStackCategory, KUidPSSMSStackDiskSpaceMonitorKey );
iSmsPhoneStoreSubscriber->Subscribe();
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::~CSysApPubSubObserver()
// ----------------------------------------------------------------------------
CSysApPubSubObserver::~CSysApPubSubObserver()
{
delete iAutolockStatusSubscriber;
delete iBatteryBarsSubscriber;
delete iBatteryLowIndicationSubscriber;
delete iBatteryCStatusSubscriber;
delete iChargerCStatusSubscriber;
delete iCallInfoSubscriber;
delete iInboxStatusSubscriber;
delete iOutboxStatusSubscriber;
delete iIrdaStatusSubscriber;
delete iGprsStatusSubscriber;
delete iWcdmaStatusSubscriber;
delete iHomeZoneStatusSubscriber;
delete iNewEmailStatusSubscriber;
delete iLocationGlobalPrivacySubscriber;
delete iRestoreBackupSubscriber;
delete iPoCIndicatorSubscriber;
delete iPoCMissedIndicatorSubscriber;
delete iTarmStatusSubscriber;
delete iMtvRecStatusSubscriber;
delete iMtvDvbhStatusSubscriber;
delete iSimChangedSubscriber;
delete iWakeupAlarmSubscriber;
delete iAlarmLightSubscriber;
delete iVTLightsSubscriber;
delete iSSLightsSubscriber;
delete iATCLightsSubscriber;
delete iLightsControlSubscriber;
delete iDisableKeyguardSubscriber;
delete iSoftRejectSubscriber;
delete iUipIndSubscriber;
delete iMessageToneQuitSubscriber;
delete iNspsRawKeyEventSubscriber;
delete iLightsRawKeyEventSubscriber;
delete iMmcRemovedWithoutEjectSubscriber;
delete iNetworkModeSubscriber;
delete iWlanIndicatorSubscriber;
delete iFlipStatusSubscriber;
delete iFmTxStatusSubscriber;
delete iFmTxRemConObserver;
delete iSyncStatusSubscriber;
delete iVideoSharingIndicatorSubscriber;
delete iGpsIndicatorSubscriber;
delete iSmsPhoneStoreSubscriber;
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandlePropertyChangedL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandlePropertyChangedL( const TUid& aCategory, const TUint aKey )
{
TInt value( 0 );
RProperty::Get( aCategory, aKey, value );
#ifdef _DEBUG
HBufC* hbuf = HBufC::New( 120 );
if ( hbuf )
{
TPtr buf = hbuf->Des();
buf = _L("CSysApPubSubObserver::HandlePropertyChangedL: category=0x");
buf.AppendNumFixedWidth( aCategory.iUid, EHex, 8 );
buf.Append( _L(", key=0x") );
buf.AppendNumFixedWidth( aKey, EHex, 8 );
buf.Append( _L(", value=") );
buf.AppendNum( value );
RDebug::Print( buf );
delete hbuf;
}
#endif
// KIrdaPropertyCategory is actually defined as KUidSystemCategory, but just in case this ever changes,
// check them separately here. The keys should have no overlap.
if ( aCategory == KUidSystemCategory || aCategory == KIrdaPropertyCategory )
{
HandleSystemCategoryL( aKey, value );
}
else if ( aCategory == KPSUidStartup || aCategory == KAlarmServerPubSubCategory )
{
HandleStartupCategoryL( aKey, value );
}
else if ( aCategory == KPSUidCoreApplicationUIs )
{
HandleCoreAppUIsCategoryL( aKey, value );
}
else if ( aCategory == KPSUidHWRMPowerState )
{
HandleHwrmPowerStateCategoryL( aKey, value );
}
else if ( aCategory == KPSUidWlan )
{
HandleWlanCategoryL( aKey, value );
}
else if ( aCategory == KPSUidCtsyCallInformation )
{
HandleTelephonyCallInformationCategoryL( aKey, value );
}
else if ( aCategory == KPSUidNetworkInfo )
{
HandleNetworkInfoCategoryL( aKey, value );
}
else if ( aCategory == KPSUidHWRM )
{
HandleHwrmCategoryL( aKey, value );
}
else if ( aCategory == KPSUidHWRMFmTx )
{
HandleHwrmFmTxCategoryL( aKey, value );
}
else if ( aCategory == KPSUidDataSynchronizationInternalKeys )
{
HandleDataSyncCategoryL( aKey, value );
}
else if ( aCategory == KPosIndicatorCategoryUid )
{
HandlePosIndicatorCategoryL( aKey, value );
}
else if ( aCategory == KUidPSSMSStackCategory )
{
HandleSmsStackCategoryL( aKey, value );
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleCoreAppUIsCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleCoreAppUIsCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KLightsAlarmLightActive:
if ( aValue == ELightsBlinking )
{
iSysApAppUi.AlertUiAlertingL( ETrue );
}
else if ( aValue == ELightsNotBlinking )
{
iSysApAppUi.AlertUiAlertingL( EFalse );
}
break;
case KLightsVTForcedLightsOn:
iSysApAppUi.HandleForcedLightsVTRequireL( aValue );
break;
case KLightsSSForcedLightsOn:
iSysApAppUi.HandleForcedLightsSSRequireL( aValue );
break;
case KLightsATCForcedLightsOn:
iSysApAppUi.HandleForcedLightsATCRequireL( aValue );
break;
case KLightsControl:
iSysApAppUi.HandleLightsRequireL();
break;
case KCoreAppUIsDisableKeyguard:
iSysApAppUi.AlertUiKeyLockOff( aValue == ECoreAppUIsDisableKeyguard );
break;
case KCoreAppUIsSoftReject:
if ( aValue == ECoreAppUIsSoftReject )
{
iSysApAppUi.DoNotEnableKeylock();
iSysApAppUi.SwitchLightsOnSoftRejectL();
}
break;
case KCoreAppUIsUipInd:
if ( aValue == ECoreAppUIsDoNotShow )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorInstantMessage, EAknIndicatorStateOff );
}
else if ( aValue == ECoreAppUIsShow )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorInstantMessage, EAknIndicatorStateOn );
}
break;
case KCoreAppUIsMessageToneQuit:
iSysApAppUi.HandleMessageTonePlayingQuitability( aValue );
break;
case KCoreAppUIsNspsRawKeyEvent:
iSysApAppUi.HandleNspsRawKeyEventL();
break;
case KCoreAppUIsLightsRawKeyEvent:
if ( aValue == ECoreAppUIsKeyEvent )
{
iSysApAppUi.HandleRawKeyEventLightsRequireL();
}
break;
case KCoreAppUIsMmcRemovedWithoutEject:
{
TUint cmd( aValue & KCoreAppUIsMmcRemovedWithoutEjectCmdMask );
if ( cmd == ECoreAppUIsEjectCommandUsed )
{
iSysApAppUi.EjectStarted( ETrue );
}
else if ( cmd == ECoreAppUIsEjectCommandNotUsed )
{
iSysApAppUi.EjectStarted( EFalse );
}
else if ( cmd == ECoreAppUIsEjectCommandUsedToDrive )
{
TInt drive( aValue >> KCoreAppUIsMmcRemovedWithoutEjectValShift );
iSysApAppUi.EjectUsed( drive );
}
break;
}
case KCoreAppUIsNewEmailStatus:
if ( aValue == ECoreAppUIsNewEmail )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorEmailMessage, EAknIndicatorStateOn );
}
else if ( aValue == ECoreAppUIsNoNewEmail )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorEmailMessage, EAknIndicatorStateOff );
}
break;
case KCoreAppUIsAutolockStatus:
if ( aValue == EAutolockOff )
{
iSysApAppUi.SetDeviceLockEnabledL( EFalse );
}
else if ( aValue > EAutolockOff ) // we are not interested in why autolock is enabled
{
iSysApAppUi.SetDeviceLockEnabledL( ETrue );
}
break;
case KCoreAppUIsPoCIndicator:
if ( aValue == ECoreAppUIsPocIndicatorOff || aValue == ECoreAppUIsPocIndicatorUninitialized )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoC, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoCDnD, EAknIndicatorStateOff );
}
else if ( aValue == ECoreAppUIsPocIndicatorDoNotDisturb )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoC, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoCDnD, EAknIndicatorStateOn );
}
else if ( aValue == ECoreAppUIsPocIndicatorConnectionOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoC, EAknIndicatorStateOn );
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoCDnD, EAknIndicatorStateOff );
}
break;
case KCoreAppUIsPoCMissedIndicator:
if ( aValue == ECoreAppUIsPocMissedIndicatorOff || aValue == ECoreAppUIsPocMissedIndicatorUninitialized )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoCMissed, EAknIndicatorStateOff );
}
else if ( aValue == ECoreAppUIsPocMissedIndicatorOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorPoCMissed, EAknIndicatorStateOn );
}
break;
case KCoreAppUIsTarmIndicator:
iSysApAppUi.HandleTarmIndicatorL( aValue );
break;
case KCoreAppUIsMtvRecStatus:
if ( aValue == ECoreAppUIsMtvRecStatusOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorMobileTVRec, EAknIndicatorStateOn );
}
else if ( aValue == ECoreAppUIsMtvRecStatusOff || aValue == ECoreAppUIsMtvRecStatusUninitialized )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorMobileTVRec, EAknIndicatorStateOff );
}
break;
case KCoreAppUIsMtvDvbhStatus:
if ( aValue == ECoreAppUIsMtvDvbhStatusOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorMobileTV, EAknIndicatorStateOn );
}
else if ( aValue == ECoreAppUIsMtvDvbhStatusOff || aValue == ECoreAppUIsMtvDvbhStatusUninitialized )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorMobileTV, EAknIndicatorStateOff );
}
break;
case KCoreAppUIsVideoSharingIndicator:
if ( aValue == ECoreAppUIsVideoSharingIndicatorOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorVideoSharing, EAknIndicatorStateOn );
}
else if ( aValue == ECoreAppUIsVideoSharingIndicatorOff || aValue == ECoreAppUIsVideoSharingIndicatorUninitialized )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorVideoSharing, EAknIndicatorStateOff );
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleStartupCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleStartupCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KPSSimOwned:
if ( aValue == ESimNotOwned )
{
TRAPD( simChangedErr, iSysApAppUi.DoSimChangedFromPreviousBootL() );
TRACES( RDebug::Print( _L("CSysApPubSubObserver::HandleStartupCategoryL: simChangedErr = %d" ), simChangedErr ) );
simChangedErr = simChangedErr; // suppress 'variable not used' warning
}
break;
case KWakeupAlarmPubSubKey:
{
TRACES( RDebug::Print(_L("CSysApPubSubObserver::HandleStartupCategoryL called CSysApAppUi::ShowAlarmIndicatorL with aShowIndicator = %d "), (aValue == EActiveWakeupAlarmSet)));
iSysApAppUi.ShowAlarmIndicatorL( aValue == EActiveWakeupAlarmSet );
break;
}
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleSystemCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleSystemCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KUidInboxStatusValue:
iSysApAppUi.SetEnvelopeIndicatorL();
break;
case KUidOutboxStatusValue:
if ( aValue == ESADocumentsInOutbox )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorOutbox, EAknIndicatorStateOn );
}
//Hide the Outbox indicator
else if ( aValue == ESAOutboxEmpty )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorOutbox, EAknIndicatorStateOff );
}
break;
case KIrdaStatus:
if ( aValue == TIrdaStatusCodes::EIrLoaded || aValue == TIrdaStatusCodes::EIrBlocked || aValue == TIrdaStatusCodes::EIrDisconnected )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateAnimate );
}
else if ( aValue == TIrdaStatusCodes::EIrConnected )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateOn );
}
else if ( aValue == TIrdaStatusCodes::EIrUnloaded )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorIrActive, EAknIndicatorStateOff );
}
break;
case KPSUidGprsStatusValue:
case KPSUidWcdmaStatusValue:
iSysApAppUi.SetSignalIndicatorL();
break;
case KPSUidLocationGlobalPrivacyValue:
iSysApAppUi.HandleLocationPrivacyIndicatorL( aValue );
break;
case conn::KUidBackupRestoreKey:
{
conn::TBURPartType partType = static_cast< conn::TBURPartType >( aValue & conn::KBURPartTypeMask );
if ( partType == conn::EBURRestoreFull || partType == conn::EBURRestorePartial )
{
iRestoreOngoing = ETrue;
}
else if ( iRestoreOngoing )
{
TRACES( RDebug::Print( _L("CSysApPubSubObserver::HandleSystemCategoryL: restore finished, make the device reset" ) ) );
User::After( 1000000 );
iSysApAppUi.ShowQueryL( ESysApRestartPhoneQuery );
}
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleHwrmPowerStateCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleHwrmPowerStateCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KHWRMBatteryLevel:
iSysApAppUi.UpdateBatteryBarsL( aValue );
break;
case KHWRMBatteryStatus:
iSysApAppUi.HandleBatteryStatusL( aValue );
break;
case KHWRMChargingStatus:
iSysApAppUi.HandleChargingStatusL( aValue );
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleHwrmFmTxCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleHwrmFmTxCategoryL( const TUint aKey,
const TInt aValue )
{
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL aKey %d, aValue %d"), aKey, aValue));
if ( aKey == KHWRMFmTxStatus )
{
TBool isFmTxTurnedOn( EFalse );
TBool isFmTxTurnedOff( EFalse );
const TInt KFmTxNotSendingIndicator( EAknIndicatorFMTxEnabled );
const TInt KFmTxActiveIndicator( EAknIndicatorFMTxSending );
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL aKey = KHWRMFmTxStatus, iPreviousFmTxPSValue = %d"), iPreviousFmTxPSValue));
switch ( iPreviousFmTxPSValue )
{
// Previous "On" states
case EFmTxStateActive:
case EFmTxStateInactive:
case EFmTxStateScanning: // equivalent to EFmTxStateInactive for UI purposes
if ( aValue == EFmTxStateUnknown || aValue == EFmTxStateOff ||
aValue == EFmTxStatePowerSaveInactivity || aValue == EFmTxStatePowerSaveAccessory )
{
// Active/Inactive -> Off state
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL Active/Inactive -> Off transition")));
// turn any FM TX indicators off
iSysApAppUi.SetIndicatorStateL( KFmTxActiveIndicator, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( KFmTxNotSendingIndicator, EAknIndicatorStateOff );
// give notification
if ( aValue == EFmTxStatePowerSaveAccessory )
{
iSysApAppUi.ShowUiNoteL( EFmTxAccessoryStandbyNote );
}
else
{
iSysApAppUi.ShowUiNoteL( EFmTxOffNote );
}
isFmTxTurnedOff = ETrue;
}
else if ( aValue == EFmTxStateInactive || aValue == EFmTxStateScanning )
{
// Active -> Inactive
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL Active -> Inactive transition")));
// enable not sending indicator
iSysApAppUi.SetIndicatorStateL( KFmTxActiveIndicator, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( KFmTxNotSendingIndicator, EAknIndicatorStateOn );
}
else if ( aValue == EFmTxStateActive )
{
// Inactive -> Active
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL Inactive -> Active transition")));
// enable active indicator
iSysApAppUi.SetIndicatorStateL( KFmTxNotSendingIndicator, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( KFmTxActiveIndicator, EAknIndicatorStateOn );
}
break;
// Previous "Off" states
case EFmTxStateUnknown:
case EFmTxStateOff:
case EFmTxStatePowerSaveInactivity:
case EFmTxStatePowerSaveAccessory:
if ( aValue == EFmTxStateActive )
{
// Off -> Active
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL Off -> Active transition")));
// enable active indicator
iSysApAppUi.SetIndicatorStateL( KFmTxNotSendingIndicator, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( KFmTxActiveIndicator, EAknIndicatorStateOn );
// give notification
iSysApAppUi.ShowUiNoteL( EFmTxOnNote );
isFmTxTurnedOn = ETrue;
}
else if ( aValue == EFmTxStateInactive || aValue == EFmTxStateScanning )
{
// Off -> Inactive
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL Off -> Inactive transition")));
// enable not sending indicator
iSysApAppUi.SetIndicatorStateL( KFmTxActiveIndicator, EAknIndicatorStateOff );
iSysApAppUi.SetIndicatorStateL( KFmTxNotSendingIndicator, EAknIndicatorStateOn );
// give notification
iSysApAppUi.ShowUiNoteL( EFmTxOnNote );
isFmTxTurnedOn = ETrue;
}
break;
}
if ( aValue == EFmTxStateActive )
{
if(iFmTxRemConObserver)
{
//Open Remcon and reserve the volume keys
iFmTxRemConObserver->StartRemconInterfaceL();
}
}
else
{
if(iFmTxRemConObserver)
{
//Disconnect from Remcon and release keys for other apps like phone app during call
iFmTxRemConObserver->StopRemconInterface();
}
}
if ( isFmTxTurnedOn )
{
if ( !iFmTxRemConObserver )
{
// create observer which captures volume keys
iFmTxRemConObserver = CSysApRemConObserver::NewL( iSysApAppUi );
}
if ( iSysApAppUi.SysApFeatureManager().FmTxRdsTextSupported() )
{
_LIT( KRdsObserverExe, "RDSEventObserver.exe" );
RProcess process;
TInt error = process.Create( KRdsObserverExe, KNullDesC );
if ( error == KErrNone )
{
process.Resume();
}
else
{
TRACES(RDebug::Print(_L("CSysApPubSubObserver::HandleHwrmFmTxCategoryL: error=%d"), error ) );
}
process.Close();
}
}
else if ( isFmTxTurnedOff )
{
delete iFmTxRemConObserver;
iFmTxRemConObserver = NULL;
}
iPreviousFmTxPSValue = aValue;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleWlanCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleWlanCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KPSWlanIndicator:
iSysApAppUi.HandleWlanIndicatorL(aValue);
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleTelephonyCallInformationCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleTelephonyCallInformationCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KCTsyCallState:
iSysApAppUi.HandleCurrentCallStateChangeL( aValue );
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleNetworkInfoCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleNetworkInfoCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KNWHomeZoneStatus:
if ( aValue == ENWHomeZone )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorHomeZone, EAknIndicatorStateOn );
}
else if ( aValue == ENWNone || aValue == ENWCityZone )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorHomeZone, EAknIndicatorStateOff );
}
break;
case KNWTelephonyNetworkMode:
iSysApAppUi.SetSignalIndicatorL();
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleHwrmCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleHwrmCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KHWRMFlipStatus:
if ( aValue == EPSHWRMFlipClosed )
{
iSysApAppUi.SimulateFlipKeyEventL( EFalse );
}
else if ( aValue == EPSHWRMFlipOpen )
{
iSysApAppUi.SimulateFlipKeyEventL( ETrue );
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleDataSyncCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleDataSyncCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KDataSyncStatus:
if ( aValue > EDataSyncNotRunning )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorSynchronization , EAknIndicatorStateOn );
}
else
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorSynchronization, EAknIndicatorStateOff );
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandlePosIndicatorCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandlePosIndicatorCategoryL( const TUint aKey, const TInt aValue )
{
switch ( aKey )
{
case KPosIntGpsHwStatus:
if ( aValue == EPosIntGpsHwOff )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorGPS, EAknIndicatorStateOff );
}
else if ( aValue == EPosIntGpsHwOn )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorGPS, EAknIndicatorStateOn );
}
else if ( aValue == EPosIntGpsHwIntermediate )
{
iSysApAppUi.SetIndicatorStateL( EAknIndicatorGPS, EAknIndicatorStateAnimate );
}
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CSysApPubSubObserver::HandleSmsStackCategoryL()
// ----------------------------------------------------------------------------
void CSysApPubSubObserver::HandleSmsStackCategoryL( const TUint aKey, const TInt /*aValue*/ )
{
switch ( aKey )
{
case KUidPSSMSStackDiskSpaceMonitorKey:
iSysApAppUi.SetEnvelopeIndicatorL();
break;
default:
break;
}
}
// End of File