/*
* Copyright (c) 2006-2008 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:  Handles dtmf
*
*/


//  INCLUDE FILES
#include "cccedtmf.h"
#include "mccpdtmfprovider.h"
#include "cccecall.h"
#include "cccelogger.h"
#include "cccecallcontainer.h"
#include "cccepluginmanager.h"

// ======== MEMBER FUNCTIONS ========
// -----------------------------------------------------------------------------
// NewL()
// -----------------------------------------------------------------------------
//
CCCEDtmf* CCCEDtmf::NewL( 
    CCCECallContainer& aCallContainer,
    CCCEPluginManager& aPluginManager )
    {
    CCCEDtmf* self = new (ELeave) CCCEDtmf( aCallContainer, aPluginManager );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CCCEDtmf() 
// -----------------------------------------------------------------------------
//
CCCEDtmf::CCCEDtmf( 
    CCCECallContainer& aCallContainer,
    CCCEPluginManager& aPluginManager ):
    iCallContainer( aCallContainer ),
    iPluginManager( aPluginManager )
    {

    }

// -----------------------------------------------------------------------------
// ConstructL()
// -----------------------------------------------------------------------------
//
void CCCEDtmf::ConstructL()
    {
    CCELOGSTRING("CCCEDtmf::ConstructL");
    }

// -----------------------------------------------------------------------------
// ~CCCEDtmf()
// -----------------------------------------------------------------------------
//
CCCEDtmf::~CCCEDtmf()
    {
    CCELOGSTRING("CCCEDtmf::~CCCEDtmf");

	while( iObservers.Count() )
		{
    	CCELOGSTRING("CCCEDtmf::~CCCEDtmf: There are dtmf observers in the array. Should be removed before dtor!");
        iObservers.Remove ( 0 );
        iObservers.Compress();
        }

    iObservers.Close();
    }

// -----------------------------------------------------------------------------
// GetDtmfProviders()
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::GetDtmfProviders( RPointerArray<MCCPDTMFProvider>& aProviders ) const
    {
    CCELOGSTRING("CCCEDtmf::GetDtmfProviders");
    RPointerArray<MCCECallInfo> calls;
    // Gets calls
    TInt err = KErrNotFound;
    MCCPDTMFProvider* provider;
    provider = NULL;
    err = iCallContainer.GetActiveOrConnectingCalls( calls );
    
    // Insert desired dtmf providers into array
    for( TInt i = 0; i < calls.Count(); i++ )
        {
        TRAPD( error, provider = 
            &iPluginManager.DtmfProviderL( *this, calls[i]->ImplementationUid() );
            );
            
        if( !error && provider )
            {
            aProviders.InsertInAddressOrder( provider );
            }
        }
        
    calls.Close();
    
    // notifies only if all providers fail to support 
    if( aProviders.Count()==0 )
        {
        err = KErrNotSupported;
        }
    return err;
    }


// -----------------------------------------------------------------------------
// CCCEDtmf::StopDtmfTone()
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::StopDtmfTone()
    {
    CCELOGSTRING("CCCEDtmf::StopDtmfTone");
    RPointerArray<MCCPDTMFProvider> dtmfproviders;

    TInt err = GetDtmfProviders( dtmfproviders );
    // Send request to desired dtmf providers
    for( TInt i = 0; i < dtmfproviders.Count(); i++ )
        {
        dtmfproviders[i]->StopDtmfTone();
        }
    dtmfproviders.Close();
    
    return err;
    }

// -----------------------------------------------------------------------------
// CCCEDtmf::StartDtmfTone( TChar /* aTone */ )
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::StartDtmfTone( TChar aTone )
    {
    CCELOGSTRING2("CCCEDtmf::StartDtmfTone %d",(TInt)aTone);
    RPointerArray<MCCPDTMFProvider> dtmfproviders;

    TInt err = GetDtmfProviders( dtmfproviders );
    // Send request to desired dtmf providers
    for( TInt i = 0; i < dtmfproviders.Count(); i++ )
        {
        dtmfproviders[i]->StartDtmfTone( aTone );
        }
        
    dtmfproviders.Close();
    
    return err;
    }
// -----------------------------------------------------------------------------
// CCCEDtmf::SendDtmfToneString( TDesC& aTones )
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::SendDtmfToneString( const TDesC& aTones )
    {
    CCELOGSTRING("CCCEDtmf::SendDtmfToneString");
    RPointerArray<MCCPDTMFProvider> dtmfproviders;

    TInt err = GetDtmfProviders( dtmfproviders );
    // Send request to desired dtmf providers
    for( TInt i = 0; i < dtmfproviders.Count(); i++ )
        {
       err = dtmfproviders[i]->SendDtmfToneString( aTones );
        }
        
    dtmfproviders.Close();
    
    return err;
    }
  
// -----------------------------------------------------------------------------
// CCCEDtmf::ContinueStringSending( TBool aContinue )
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::ContinueStringSending( TBool aContinue )
    {
    CCELOGSTRING2("CCCEDtmf::SendDtmfToneString %d",aContinue);
    RPointerArray<MCCPDTMFProvider> dtmfproviders;

    TInt err = GetDtmfProviders( dtmfproviders );
    // Send request to desired dtmf providers
    for( TInt i = 0; i < dtmfproviders.Count(); i++ )
        {
        err = dtmfproviders[i]->ContinueDtmfStringSending( aContinue );
        }
        
    dtmfproviders.Close();
    
    return err;
    }
 
// -----------------------------------------------------------------------------
// CCCEDtmf::CancelDtmfStringSending()
// -----------------------------------------------------------------------------
//
void CCCEDtmf::CancelDtmfStringSending()
    {
    CCELOGSTRING("CCCEDtmf::CancelDtmfStringSending");
    RPointerArray<MCCPDTMFProvider> dtmfproviders;

    GetDtmfProviders( dtmfproviders );
    // Send request to desired dtmf providers
    for( TInt i = 0; i < dtmfproviders.Count(); i++ )
        {
        dtmfproviders[i]->CancelDtmfStringSending();
        }
        
    dtmfproviders.Close();
    }

// -----------------------------------------------------------------------------
// CCCEDtmf::SetDtmfObserver( MCCEDtmfObserver& aObserver )
// -----------------------------------------------------------------------------
//
void CCCEDtmf::SetObserver( const MCCEDtmfObserver& aObserver )
    {
    CCELOGSTRING("CCCEDtmf::SetObserver. Will be deprecated, start using AddObserver instead!");

    // deprecated, not supported anymore!!! Remove from API later on!
    
    // 26.11.2007 support for old way SetObserver. Remove this when changes to phone are done!!!
    TRAP_IGNORE(AddObserverL(aObserver));
    } 
    
// -----------------------------------------------------------------------------
// CCCEDtmf::AddObserverL( MCCEDtmfObserver& aObserver )
// -----------------------------------------------------------------------------
//
void CCCEDtmf::AddObserverL( const MCCEDtmfObserver& aObserver )
    {
    CCELOGSTRING("CCCEDtmf::AddObserverL");

    if( iObservers.Find( &aObserver )==KErrNotFound )
        {
        iObservers.AppendL( &aObserver );
        }
    else
        {
        // already added, ignore 
	CCELOGSTRING("CCCEDtmf::AddObserverL. Observer to be added already existed. Operation ignored!");
        }    
    }    

// -----------------------------------------------------------------------------
// CCCEDtmf::RemoveObserver( MCCEDtmfObserver& aObserver )
// -----------------------------------------------------------------------------
//
TInt CCCEDtmf::RemoveObserver( const MCCEDtmfObserver& aObserver )
    {
    CCELOGSTRING("CCCEDtmf::RemoveObserver");
    TInt index = iObservers.Find( &aObserver );	
    
    if( index!=KErrNotFound )
        {
        iObservers.Remove ( index );
        iObservers.Compress();
        }
	else
		{
		return KErrNotFound;
		}

    return KErrNone;
    } 

// ---------------------------------------------------------------------------
// From class MCCPDTMFObserver
// ---------------------------------------------------------------------------
//
void CCCEDtmf::HandleDTMFEvent( const TCCPDtmfEvent aEvent,
                                const TInt aError,
                                const TChar aTone ) const
    {
    CCELOGSTRING ("CCCEDtmf::HandleDTMFEvent");
    CCELOGSTRING2 ("    HandleDTMFEvent, event = %d ",aEvent );
    CCELOGSTRING2 ("    HandleDTMFEvent, error = %d ",aError );
    CCELOGSTRING2 ("    HandleDTMFEvent, tone = %d ",(TInt)aTone );
    
    MCCEDtmfObserver::TCCEDtmfEvent event = (MCCEDtmfObserver::TCCEDtmfEvent)(aEvent);
    
	for( TInt i=0; i<iObservers.Count(); i++ )
	    {
		// notify all observers
    		const_cast<MCCEDtmfObserver*>(iObservers[i])->HandleDTMFEvent( event,
        										 					   aError, 
        															   aTone );
        }
    }