/*

* 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 	<etelmm.h>

#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;

    }