diff -r ebe688cedc25 -r 7fdbb852d323 messagingappbase/ncnlist/src/CNcnMsgWaitingManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/ncnlist/src/CNcnMsgWaitingManager.cpp Wed Sep 01 12:31:54 2010 +0100 @@ -0,0 +1,622 @@ +/* +* Copyright (c) 2004 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: Methods for CNcnMsgWaitingManager class. +* +*/ + + + +// INCLUDE FILES +#include + +#include "NcnVariant.hrh" +#include "NcnDebug.h" +#include "NcnModelBase.h" +#include "CNcnMsgWaitingManager.h" +#include "CVoiceMailManager.h" + +#ifdef _DEBUG + +class CNcnMsgWaitingManagerObserver : + public CActive + { + public: // Constructors and destructor + + /** + * Two-phased constructor. + * @param aModel Reference to ncn model + */ + static CNcnMsgWaitingManagerObserver* NewL( RMobilePhone &aMobilePhone ); + + /** + * Destructor. + */ + virtual ~CNcnMsgWaitingManagerObserver(); + + public: // From CActive + + /** + * RunL + */ + void RunL(); + + /** + * DoCancel + */ + void DoCancel(); + + private: // Constructors and destructor + + /** + * C++ default constructor. + * @param aMsvSessionHandler Msv session handler reference. + */ + CNcnMsgWaitingManagerObserver( RMobilePhone &aMobilePhone ); + + /** + * 2nd. phase constructor. + */ + void ConstructL( ); + + private: + + void PrintStatus(); + + private: // Data + + TBool iChangeNotifySubscribed; + + RMobilePhone &iMobilePhone; + + // Struct is a container for indicator flags and message counts + RMobilePhone::TMobilePhoneMessageWaitingV1 iMsgWaiting; + + // Package for iMsgWaitingV1 + RMobilePhone::TMobilePhoneMessageWaitingV1Pckg iMsgWaitingPckg; + + + }; // CNcnMsgWaitingManagerObserver + + + + + CNcnMsgWaitingManagerObserver::CNcnMsgWaitingManagerObserver( RMobilePhone &aMobilePhone ) : + CActive( EPriorityNormal ), + iChangeNotifySubscribed( EFalse ), + iMobilePhone( aMobilePhone ), + iMsgWaiting(), + iMsgWaitingPckg( iMsgWaiting ) + { + CActiveScheduler::Add( this ); + } + + CNcnMsgWaitingManagerObserver* CNcnMsgWaitingManagerObserver::NewL( RMobilePhone &aMobilePhone ) + { + CNcnMsgWaitingManagerObserver* self = new (ELeave) CNcnMsgWaitingManagerObserver( aMobilePhone ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + + void CNcnMsgWaitingManagerObserver::ConstructL() + { + //iMobilePhone.GetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg ); + //SetActive(); + } + + CNcnMsgWaitingManagerObserver::~CNcnMsgWaitingManagerObserver() + { + NCN_RDEBUG( _L("~CNcnMsgWaitingManager") ); + Cancel(); + } + + + void CNcnMsgWaitingManagerObserver::RunL() + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::RunL: iStatus = %d"), iStatus.Int() ); + TInt err = iStatus.Int(); + + // subscribe for notifications + iMobilePhone.NotifyIccMessageWaitingIndicatorsChange( iStatus, iMsgWaitingPckg ); + SetActive(); + + iChangeNotifySubscribed = ETrue; // get-request completed, DoCancel() must now cancel notify request + + if ( err == KErrNone ) + { + PrintStatus(); + } + } + + void CNcnMsgWaitingManagerObserver::DoCancel() + { + if ( IsActive() ) + { + if ( iChangeNotifySubscribed ) + { + iMobilePhone.CancelAsyncRequest( EMobilePhoneNotifyIccMessageWaitingIndicatorsChange ); + } + else + { + iMobilePhone.CancelAsyncRequest( EMobilePhoneGetIccMessageWaitingIndicators ); + } + } + } + + void CNcnMsgWaitingManagerObserver::PrintStatus() + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Voice mail line 1 active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayVoicemailActive ) ? ETrue : EFalse ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Voice mail line 2 active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayAuxVoicemailActive ) ? ETrue : EFalse ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Fax active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayFaxActive ) ? ETrue : EFalse ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Email active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayEmailActive ) ? ETrue : EFalse ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Other active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayOtherActive ) ? ETrue : EFalse ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Display data active %d"), + ( iMsgWaiting.iDisplayStatus& RMobilePhone::KDisplayDataActive ) ? ETrue : EFalse ); + + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Voice mail line 1 count %d"), + iMsgWaiting.iVoiceMsgs ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Voice mail line 2 count %d"), + iMsgWaiting.iAuxVoiceMsgs ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Fax count %d"), + iMsgWaiting.iFaxMsgs ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Email count %d"), + iMsgWaiting.iEmailMsgs ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManagerObserver::PrintStatus: Other message count %d"), + iMsgWaiting.iOtherMsgs ); + } + + +#endif // _DEBUG + +// ================= LOCAL CONSTANTS ======================= + + +// ================= MEMBER FUNCTIONS ======================= + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::CNcnMsgWaitingManager +// ---------------------------------------------------- +// +CNcnMsgWaitingManager::CNcnMsgWaitingManager( CNcnModelBase &aModel ) : + CActive( EPriorityNormal ), + iModel( aModel ), + iMsgWaiting(), + iMsgWaitingPckg( iMsgWaiting ) + { + CActiveScheduler::Add( this ); + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::NewL +// ---------------------------------------------------- +// +CNcnMsgWaitingManager* CNcnMsgWaitingManager::NewL( CNcnModelBase &aModel ) + { + CNcnMsgWaitingManager* self = new (ELeave) CNcnMsgWaitingManager( aModel ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::ConstructL +// ---------------------------------------------------- +// +void CNcnMsgWaitingManager::ConstructL() + { + TInt err; + + err = iTelServer.Connect(); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::ConstructL: iTelServer.Connect returned %d"), err ); + User::LeaveIfError( err ); + + err = iTelServer.GetPhoneInfo( 0, iPhoneInfo ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::ConstructL: iTelServer.GetPhoneInfo returned %d"), err ); + User::LeaveIfError( err ); + + err = iMobilePhone.Open( iTelServer, iPhoneInfo.iName ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::ConstructL: iMobilePhone.Open returned %d"), err ); + User::LeaveIfError( err ); + +#if 0 + iObserver = CNcnMsgWaitingManagerObserver::NewL( iMobilePhone ); +#endif + + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::GetFirstIndicatorStatus +// ---------------------------------------------------- +// +void CNcnMsgWaitingManager::GetFirstIndicatorStatus() + { + Cancel(); + iState = ENcnGetIndicator; + iStatus = KRequestPending; + iMobilePhone.GetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetFirstIndicatorStatus: iMobilePhone.GetIccMessageWaitingIndicators iStatus %d"), iStatus.Int() ); + SetActive(); + + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetFirstIndicatorStatus: GetIccMessageWaitingIndicators returned %d"), iStatus.Int() ); + + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::~CNcnMsgWaitingManager +// ---------------------------------------------------- +// +CNcnMsgWaitingManager::~CNcnMsgWaitingManager() + { + Cancel(); + +#ifdef _DEBUG + if( iObserver ) + { + iObserver->Cancel(); + delete iObserver; + } +#endif + + iMobilePhone.Close(); + iTelServer.Close(); + + iReqQueue.Close(); + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::RunL +// ---------------------------------------------------- +// +void CNcnMsgWaitingManager::RunL() + { + TInt err = iStatus.Int(); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::RunL: iState %d"), iState ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::RunL: return value %d"), err ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::RunL: there are %d requests in queue"), iReqQueue.Count() ); + +#ifdef _DEBUG + NCN_RDEBUG( _L("CNcnMsgWaitingManager::RunL: Following requests are in queue:") ); + for( int i = 0; i < iReqQueue.Count(); ++i ) + { + TNcnReqQueueElement elem = iReqQueue[0]; + NCN_RDEBUG_INT2( _L("%d: iCmd = %d"), i, elem.iCmd ); + NCN_RDEBUG_INT2( _L("%d: iField = %d"), i, elem.iField ); + NCN_RDEBUG_INT2( _L("%d: iParam1 = %d"), i, elem.iParam1 ); + NCN_RDEBUG_INT2( _L("%d: iParam2 = %d"), i, elem.iParam2 ); + } +#endif + + // Check if there is any requests in work queue. + if( iReqQueue.Count() ) + { + TNcnReqQueueElement elem = iReqQueue[0]; + iReqQueue.Remove( 0 ); +#ifdef _DEBUG + NCN_RDEBUG( _L("CNcnMsgWaitingManager::RunL: Handling request:") ); + NCN_RDEBUG_INT( _L("0: iCmd = %d"), elem.iCmd ); + NCN_RDEBUG_INT( _L("0: iField = %d"), elem.iField ); + NCN_RDEBUG_INT( _L("0: iParam1 = %d"), elem.iParam1 ); + NCN_RDEBUG_INT( _L("0: iParam2 = %d"), elem.iParam2 ); +#endif + iState = elem.iCmd; + if( elem.iCmd == ENcnSetCount ) + { + SetMessageCount( (TNcnMessageType)elem.iField, elem.iParam1, elem.iParam2 ); + } + else if( elem.iCmd == ENcnSetIndicator ) + { + SetIndicator( (TNcnIndicator)elem.iField, elem.iParam1 ); + } + } + else + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::RunL: state ENcnIdle") ); + iState = ENcnIdle; + } + + + if ( !iConstructionReady ) + { + iConstructionReady = ETrue; + iModel.VoiceMailManager().UpdateVMNotifications(); + + } + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::RunError +// ---------------------------------------------------- +// +TInt CNcnMsgWaitingManager::RunError( TInt aError ) + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::RunError: aError %d"), aError ); + + return aError; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::DoCancel +// ---------------------------------------------------- +// +void CNcnMsgWaitingManager::DoCancel() + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::DoCancel: iState %d"), iState ); + + if( IsActive() ) + { + switch( iState ) + { + case ENcnGetIndicator: + case ENcnGetCount: + iMobilePhone.CancelAsyncRequest( EMobilePhoneGetIccMessageWaitingIndicators ); + iState = ENcnIdle; + break; + case ENcnSetIndicator: + case ENcnSetCount: + iMobilePhone.CancelAsyncRequest( EMobilePhoneSetIccMessageWaitingIndicators ); + iState = ENcnIdle; + break; + case ENcnNotifyMsgWaiting: + iMobilePhone.CancelAsyncRequest( EMobilePhoneNotifyIccMessageWaitingIndicatorsChange ); + iState = ENcnIdle; + break; + default: + break; + } + } + } + + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::SetIndicator +// ---------------------------------------------------- +// +TInt CNcnMsgWaitingManager::SetIndicator( + const TNcnIndicator aIndicator, + TBool aEnable ) + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetIndicator: iState %d"), iState ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetIndicator: indicator %d"), aIndicator ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetIndicator: enable %d"), aEnable ); + + switch( aIndicator ) + { + case ENcnIndicatorFax: + DoSetIndicator( RMobilePhone::KDisplayFaxActive, aEnable ); + break; + + case ENcnIndicatorEmail: + DoSetIndicator( RMobilePhone::KDisplayEmailActive, aEnable ); + break; + + case ENcnIndicatorOther: + DoSetIndicator( RMobilePhone::KDisplayOtherActive, aEnable ); + break; + + case ENcnIndicatorVMLine1: + DoSetIndicator( RMobilePhone::KDisplayVoicemailActive, aEnable ); + break; + + case ENcnIndicatorVMLine2: + DoSetIndicator( RMobilePhone::KDisplayAuxVoicemailActive, aEnable ); + break; + + default: + break; + } + + if( IsActive() ) + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::SetIndicator: Already actived. Adding request to queue") ); + TNcnReqQueueElement elem( ENcnSetIndicator, aIndicator, aEnable ); + iReqQueue.Append( elem ); + } + else + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::SetIndicator: Activating waiting manager") ); + iState = ENcnSetIndicator; + iStatus = KRequestPending; + iMobilePhone.SetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg ); + SetActive(); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetIndicator: iStatus %d"), iStatus.Int() ); + } + + return KErrNone; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::DoSetIndicator +// ---------------------------------------------------- +// +void CNcnMsgWaitingManager::DoSetIndicator( TInt aId, TBool aEnable ) + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::DoSetIndicator") ); + if( aEnable ) + { + iMsgWaiting.iDisplayStatus |= aId; + } + else + { + iMsgWaiting.iDisplayStatus &= ~ aId; + } + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::SetMessageCount +// ---------------------------------------------------- +// +TInt CNcnMsgWaitingManager::SetMessageCount( + const TNcnMessageType aMsgType, + TUint aCount, + TBool aEnableIndicator ) + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetMessageCount: iState %d"), iState ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetMessageCount: message type %d"), aMsgType ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetMessageCount: message count %d"), aCount ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetMessageCount: enable indicator %d"), aEnableIndicator ); + + switch( aMsgType ) + { + case ENcnMessageTypeFax: + DoSetIndicator( RMobilePhone::KDisplayFaxActive, aEnableIndicator ); + iMsgWaiting.iFaxMsgs = aCount; + break; + + case ENcnMessageTypeEmail: + DoSetIndicator( RMobilePhone::KDisplayEmailActive, aEnableIndicator ); + iMsgWaiting.iEmailMsgs = aCount; + break; + + case ENcnMessageTypeOther: + DoSetIndicator( RMobilePhone::KDisplayOtherActive, aEnableIndicator ); + iMsgWaiting.iOtherMsgs = aCount; + break; + + case ENcnMessageTypeVMLine1: + DoSetIndicator( RMobilePhone::KDisplayVoicemailActive, aEnableIndicator ); + iMsgWaiting.iVoiceMsgs = aCount; + break; + + case ENcnMessageTypeVMLine2: + DoSetIndicator( RMobilePhone::KDisplayAuxVoicemailActive, aEnableIndicator ); + iMsgWaiting.iAuxVoiceMsgs = aCount; + break; + + default: + break; + } + + if( IsActive() ) + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::SetMessageCount: Already actived. Adding request to queue") ); + TNcnReqQueueElement elem( ENcnSetCount, aMsgType, aEnableIndicator, aCount ); + iReqQueue.Append( elem ); + } + else + { + NCN_RDEBUG( _L("CNcnMsgWaitingManager::SetMessageCount: Activating waiting manager") ); + iState = ENcnSetCount; + iStatus = KRequestPending; + iMobilePhone.SetIccMessageWaitingIndicators( iStatus, iMsgWaitingPckg ); + SetActive(); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::SetMessageCount: iStatus %d"), iStatus.Int() ); + } + + return KErrNone; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::GetMessageCount +// ---------------------------------------------------- +// +TInt CNcnMsgWaitingManager::GetMessageCount( const TNcnMessageType aMsgType, TUint &aCount ) + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetMessageCount: iState %d"), iState ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetMessageCount: message type %d"), aMsgType ); + + // Is there a need to refresh message counts at this point? + switch( aMsgType ) + { + case ENcnMessageTypeFax: + aCount = iMsgWaiting.iFaxMsgs; + break; + + case ENcnMessageTypeEmail: + aCount = iMsgWaiting.iEmailMsgs; + break; + + case ENcnMessageTypeOther: + aCount = iMsgWaiting.iOtherMsgs; + break; + + case ENcnMessageTypeVMLine1: + aCount = iMsgWaiting.iVoiceMsgs; + break; + + case ENcnMessageTypeVMLine2: + aCount = iMsgWaiting.iAuxVoiceMsgs; + break; + + default: + break; + } + + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetMessageCount: message count %d"), aCount ); + + return KErrNone; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::GetIndicator +// ---------------------------------------------------- +// +TInt CNcnMsgWaitingManager::GetIndicator( const TNcnIndicator aIndicator, TBool& aEnabled ) + { + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetIndicator: iState %d"), iState ); + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetIndicator: aIndicator %d"), aIndicator ); + + switch( aIndicator ) + { + case ENcnIndicatorFax: + aEnabled = ( iMsgWaiting.iDisplayStatus & RMobilePhone::KDisplayFaxActive ) ? ETrue : EFalse; + break; + + case ENcnIndicatorEmail: + aEnabled = ( iMsgWaiting.iDisplayStatus & RMobilePhone::KDisplayEmailActive ) ? ETrue : EFalse; + break; + + case ENcnIndicatorOther: + aEnabled = ( iMsgWaiting.iDisplayStatus & RMobilePhone::KDisplayOtherActive ) ? ETrue : EFalse; + break; + + case ENcnIndicatorVMLine1: + aEnabled = ( iMsgWaiting.iDisplayStatus & RMobilePhone::KDisplayVoicemailActive ) ? ETrue : EFalse; + break; + + case ENcnIndicatorVMLine2: + aEnabled = ( iMsgWaiting.iDisplayStatus & RMobilePhone::KDisplayAuxVoicemailActive ) ? ETrue : EFalse; + break; + + default: + break; + } + + NCN_RDEBUG_INT( _L("CNcnMsgWaitingManager::GetIndicator: indicator state %d"), aEnabled ); + + return KErrNone; + } + +// ---------------------------------------------------- +// CNcnMsgWaitingManager::ConstructionReady +// ---------------------------------------------------- +// +TBool CNcnMsgWaitingManager::ConstructionReady() + { + return iConstructionReady; + } + + + +// End of File