/*

* Copyright (c) 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:   Sends and receives DTMF tones

*

*/

#include <cconvergedcallprovider.h>

#include "cvccdtmfprovider.h"

#include "cvccdirector.h"

#include "rubydebug.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Symbian constructor

// ---------------------------------------------------------------------------

//

CVccDtmfProvider* CVccDtmfProvider::NewL(

        RPointerArray<CConvergedCallProvider>& /*aProviders*/, 

        const MCCPDTMFObserver& aObserver,

        CVccDirector& aDirector )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::NewL" );

	CVccDtmfProvider* self;

	self = new( ELeave ) CVccDtmfProvider( aObserver, aDirector );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CVccDtmfProvider::~CVccDtmfProvider()

	{

	iObservers.Close();

	iProviders.Close();

	}

// ---------------------------------------------------------------------------

// CVccDtmfProvider::CVccDtmfProvider

// C++ default constructor can NOT contain any code, that might leave.

// ---------------------------------------------------------------------------

//

CVccDtmfProvider::CVccDtmfProvider( const MCCPDTMFObserver& aObserver,

                                    CVccDirector& aDirector):

    iDirector( &aDirector )                                   

    {

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::CVccDtmfProvider" );		

    iObservers.InsertInAddressOrder( &aObserver );

    }

// ---------------------------------------------------------------------------

// 2nd phase constructor

// ---------------------------------------------------------------------------

//

void CVccDtmfProvider::ConstructL()

	{

    RUBY_DEBUG_BLOCKL( "CVccDtmfProvider::ConstructL" );

	}

// ---------------------------------------------------------------------------

// @ see MCCPDTMFObserver::HandleDTMFEvent

// ---------------------------------------------------------------------------

//

void CVccDtmfProvider::HandleDTMFEvent( const MCCPDTMFObserver::TCCPDtmfEvent aEvent,

								        const TInt aError,

								        const TChar aTone ) const

    {

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::HandleDTMFEvent" );	

    RUBY_DEBUG1( "CVccDtmfProvider::HandleDTMFEvent -- obs count: %d",

                                                  iObservers.Count() );

    for ( TInt i = 0; i < iObservers.Count(); i++ )

        {

        iObservers[i]->HandleDTMFEvent( aEvent, aError, aTone );

        }    

    }

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::CancelDtmfStringSending

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::CancelDtmfStringSending()

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::CancelDtmfStringSending" );

    RUBY_DEBUG1( "-- call type = %d (0 = cs, 4 = ps)",

                        iDirector->CurrentCallTypeForDTMF() );

    TInt err( KErrNotSupported );

    CConvergedCallProvider* prov = iDirector->GetProvider();

    if( prov )

        {

        MCCPDTMFProvider* dtmf = NULL;

        TRAPD( err1, dtmf = prov->DTMFProviderL( *this ) );

        if( err1 == KErrNone )

            {

            err = dtmf->CancelDtmfStringSending();

            }

        else

            {

            err = err1;

            }

        }

    RUBY_DEBUG1( "err = %d ", err );

    return err;

	}

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::StartDtmfTone

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::StartDtmfTone( const TChar aTone )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::StartDtmfTone" );

    RUBY_DEBUG1( "-- call type = %d (0 = cs, 4 = ps)",

                         iDirector->CurrentCallTypeForDTMF() );

    TInt err( KErrNotSupported );

    CConvergedCallProvider* prov = iDirector->GetProvider();

    if( prov )

        {

        MCCPDTMFProvider* dtmf = NULL;

        TRAPD( err1, dtmf = prov->DTMFProviderL( *this ) );

        if( err1 == KErrNone )

            {

            err = dtmf->StartDtmfTone( aTone );

            }

        else

            {

            err = err1;

            }

        }

    return err;

	}

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::StopDtmfTone

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::StopDtmfTone()

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::StopDtmfTone" );

    RUBY_DEBUG1( "-- call type = %d (0 = cs, 4 = ps)",

                       iDirector->CurrentCallTypeForDTMF() );

    TInt err( KErrNotSupported );

    CConvergedCallProvider* prov = iDirector->GetProvider();

    if( prov )

        {

        MCCPDTMFProvider* dtmf = NULL;

        TRAPD( err1, dtmf = prov->DTMFProviderL( *this ) );

        if( err1 == KErrNone )

            {

            err = dtmf->StopDtmfTone();

            }

        else

            {

            err = err1;

            }

        }

    return err;

	}

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::SendDtmfToneString

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::SendDtmfToneString( const TDesC& aString )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::SendDtmfToneString" );

    RUBY_DEBUG1( "-- call type = %d (0 = cs, 4 = ps)",

                      iDirector->CurrentCallTypeForDTMF() );

    TInt err( KErrNotSupported );

    CConvergedCallProvider* prov = iDirector->GetProvider();

    if( prov )

        {

        MCCPDTMFProvider* dtmf = NULL;

        TRAPD( err1, dtmf = prov->DTMFProviderL( *this ) );

        if( err1 == KErrNone )

            {

            err = dtmf->SendDtmfToneString( aString );

            }

        else

            {

            err = err1;

            }

        }

    RUBY_DEBUG1( "err = %d ", err );

    return err;

	}

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::ContinueDtmfStringSending

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::ContinueDtmfStringSending( const TBool aContinue )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::ContinueDtmfStringSending" );

    RUBY_DEBUG1( "-- call type = %d (0 = cs, 4 = ps)", 

                        iDirector->CurrentCallTypeForDTMF() );

    TInt err ( KErrNotSupported );

    CConvergedCallProvider* prov = iDirector->GetProvider();

    if( prov )

        {

        MCCPDTMFProvider* dtmf = NULL;

        TRAPD( err1, dtmf = prov->DTMFProviderL( *this ) );

        if( err1 == KErrNone )

            {

            err = dtmf->ContinueDtmfStringSending( aContinue );

            }

        else

            {

            err = err1;

            }

        }

    return err;

    }

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::AddObserverL

// ---------------------------------------------------------------------------

//

void CVccDtmfProvider::AddObserverL( const MCCPDTMFObserver& aObserver )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::AddObserverL" );

    iObservers.InsertInAddressOrderL( &aObserver );

	}

// ---------------------------------------------------------------------------

// @see MCCPDTMFProvider::RemoveObserver

// ---------------------------------------------------------------------------

//

TInt CVccDtmfProvider::RemoveObserver( const MCCPDTMFObserver& aObserver )

	{

    RUBY_DEBUG_BLOCK( "CVccDtmfProvider::RemoveObserver" );

    TInt res = iObservers.Find( &aObserver );

    if ( res != KErrNotFound )

        {

        iObservers.Remove( res );

        res = KErrNone;

        }

    return res;

	}