/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Contains the implementation of class CSPEtelCallWaitingRequester
*
*/



#include "cspetelcallwaitingrequester.h"

#include <mmretrieve.h>
#include <etelmm.h>

#include "csplogger.h"
#include "cspconsts.h"


// ---------------------------------------------------------------------------
// Constructs the requester via two phased constructing.
// ---------------------------------------------------------------------------
//
CSPEtelCallWaitingRequester* CSPEtelCallWaitingRequester::NewL(
            RMobilePhone& aPhone ) 
    {
    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallWaitingRequester::NewL()" );
    CSPEtelCallWaitingRequester* self = 
        new ( ELeave ) CSPEtelCallWaitingRequester( aPhone );
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );    
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor of the object.
// ---------------------------------------------------------------------------
//
CSPEtelCallWaitingRequester::~CSPEtelCallWaitingRequester( )
    {
    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallWaitingRequester::~CSPEtelCallWaitingRequester()" );
    Cancel();
    delete iList;
    }

// ---------------------------------------------------------------------------
// CSPEtelCallWaitingRequester::GetCallWaitingL
// ---------------------------------------------------------------------------
//
void CSPEtelCallWaitingRequester::GetCallWaitingL( const CCCECallParameters& 
                                                      aParams,
                                                   TBool& aCallWaitingStatus )
    {
    CSPLOGSTRING(CSPINT, "CSPEtelCallWaitingRequester::GetCallWaitingL()" );
    
    if ( iMode == ECwRequesterInactive )
        {
        iMode = ECwRequesterGetStarted;
        iList->Start( iStatus );
        SetActive();
        iWait.Start();
        
        if ( iStatus == -5252 )
            {
            aCallWaitingStatus = ETrue; 
            }
        else
            {
            // Get the list of call waiting entries
            CMobilePhoneCWList* cwList = iList->RetrieveListL();
            CleanupStack::PushL(cwList);
            
            TInt count = cwList->Enumerate();
            RMobilePhone::TMobilePhoneCWInfoEntryV1 cwInfo;        
            
            aCallWaitingStatus = EFalse; // Default false
            CSPLOGSTRING(CSPINT, "CSPEtelCallWaitingRequester::GetCallWaitingL() iterate" );
            for( TInt i=0; i < count ; i++ )
               {
               cwInfo = cwList->GetEntryL( i );
     
                if ( cwInfo.iStatus == RMobilePhone::ECallWaitingStatusActive )
                    {
                    if ( cwInfo.iServiceGroup == RMobilePhone::EAuxVoiceService )
                        {
                        iAuxLineCwStatus = ETrue;
                        }
                    else
                        {
                        iPrimaryLineCwStatus = ETrue;
                        }
                    }
               }       
            
            GetCallWaitingStatusByLineType( aParams, aCallWaitingStatus );
            
            CSPLOGSTRING2(CSPINT, 
                "CSPEtelCallWaitingRequester::GetCallWaitingL() res:%d", 
                        aCallWaitingStatus );
            CleanupStack::PopAndDestroy( cwList );
            
            // Initial value has been read from network, 
            // now we must keep the setting value up to date.
            StartMonitoring();
            }           
        }

    else if ( iMode == ECwRequesterMonitoring )
        {
        CSPLOGSTRING(CSPINT, "CSPEtelCallWaitingRequester::GetCallWaitingL() use cached value" );
        GetCallWaitingStatusByLineType( aParams, aCallWaitingStatus );
        }       
    else if ( iMode == ECwRequesterGetStarted )
        {
        CSPLOGSTRING(CSPINT, "CSPEtelCallWaitingRequester::GetCallWaitingL() KErrInUse" );
        User::Leave( KErrInUse );
        }       
    }
    
// ---------------------------------------------------------------------------
// From CActive
// CSPEtelCallWaitingRequester::RunL
// ---------------------------------------------------------------------------
//
void CSPEtelCallWaitingRequester::RunL()
    {
    CSPLOGSTRING2( CSPREQEND, "CSPEtelCallWaitingRequester::RunL: status: %d", 
                              iStatus.Int() );
    if ( iWait.IsStarted() )
        {
        iWait.AsyncStop();
        }
    else if ( KErrNone == iStatus.Int() )
        {
        RMobilePhone::TMobilePhoneCWInfoEntryV1 cwInfo = iDesCwStatus();
        switch (cwInfo.iStatus)
            {
            case RMobilePhone::ECallWaitingStatusActive:
                if ( cwInfo.iServiceGroup == RMobilePhone::EAuxVoiceService )
                    {
                    iAuxLineCwStatus = ETrue;
                    }
                else
                    {
                    iPrimaryLineCwStatus = ETrue;
                    }
                break;
            case RMobilePhone::ECallWaitingStatusNotActive:
                if ( cwInfo.iServiceGroup == RMobilePhone::EAuxVoiceService )
                    {
                    iAuxLineCwStatus = EFalse;
                    }
                else
                    {
                    iPrimaryLineCwStatus = EFalse;
                    }   
                break;
            default:
                break;
            }            
        
        CSPLOGSTRING3(CSPINT, 
                        "CSPEtelCallWaitingRequester::RunL: service:%d new cw status:%d", 
                        cwInfo.iServiceGroup, cwInfo.iStatus );
        
        StartMonitoring();
        }
    else
        {
        iMode = ECwRequesterInactive;
        }
    }

// ---------------------------------------------------------------------------
// From CActive
// CSPEtelCallWaitingRequester::DoCancel
// ---------------------------------------------------------------------------
//
void CSPEtelCallWaitingRequester::DoCancel()
    {
    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallWaitingRequester::DoCancel()" );
    if ( iMode == ECwRequesterGetStarted )
        {
        iList->Cancel();
        iMode = ECwRequesterInactive;
        }
    else if ( iMode == ECwRequesterMonitoring )
        {
        iPhone.CancelAsyncRequest( EMobilePhoneNotifyCallWaitingStatusChange );
        iMode = ECwRequesterInactive;
        }
    }

// ---------------------------------------------------------------------------
// Constructs the requester.
// ---------------------------------------------------------------------------
//
CSPEtelCallWaitingRequester::CSPEtelCallWaitingRequester(RMobilePhone& aPhone): 
    CActive( EPriorityStandard ),
    iPhone( aPhone )
    {
    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallWaitingRequester::CSPEtelCallWaitingRequester()" );
    CActiveScheduler::Add( this );
    iPrimaryLineCwStatus = EFalse;
    iAuxLineCwStatus = EFalse;
    iMode = ECwRequesterInactive;
    }

// ---------------------------------------------------------------------------
// CSPEtelCallWaitingRequester::ConstructL
// ---------------------------------------------------------------------------
//    
void CSPEtelCallWaitingRequester::ConstructL()
    {
    CSPLOGSTRING(CSPINT, "CSPEtelCallWaitingRequester::ConstructL()" );
    iList = CRetrieveMobilePhoneCWList::NewL(iPhone);
    }

// ---------------------------------------------------------------------------
// Start listening call waiting status change notifications. 
// ---------------------------------------------------------------------------
//
void CSPEtelCallWaitingRequester::StartMonitoring()
    {
    iPhone.NotifyCallWaitingStatusChange( iStatus, iDesCwStatus );
    SetActive();
    iMode = ECwRequesterMonitoring;
    }

// ---------------------------------------------------------------------------
// Returns the call waiting status from call waiting status list by linetype.
// ---------------------------------------------------------------------------
//
void CSPEtelCallWaitingRequester::GetCallWaitingStatusByLineType( const CCCECallParameters& 
                                                                    aParams,
                                                                  TBool& aCallWaitingStatus )
    {
    CSPLOGSTRING(CSPOBJECT, "CSPEtelCallWaitingRequester:GetCallWaitingStatusByLineType" );
    
    if ( aParams.LineType() == CCCECallParameters::ECCELineTypePrimary )
        {
        aCallWaitingStatus = iPrimaryLineCwStatus;
        }
    else
        {
        aCallWaitingStatus = iAuxLineCwStatus;
        }
    CSPLOGSTRING3(CSPINT, 
                "CSPEtelCallWaitingRequester::GetCallWaitingStatusByLineType: line:%d res:%d", 
                        aParams.LineType(), aCallWaitingStatus );
    }

// End of file