/*
* Copyright (c) 2004 - 2006 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:  Handler for DTMF sending.
*
*/


// INCLUDE FILES
#include    "CVtEngDtmfHandler.h"
#include    "CVtEngMediaHandler.h"
#include    "VtEngPanic.h"
#include    "cvtlogger.h"

// LOCAL MACROS
#define DTMF_STATES_COUNT 3
const TInt KProtoDtmfCommandId = -1;

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

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::NewL
//
// -----------------------------------------------------------------------------
//
CVtEngDtmfHandler* CVtEngDtmfHandler::NewL( MVtH324ConfigCommand& aH324Config )
    {
    __VTPRINTENTER( "DTMF.New" )
    CVtEngDtmfHandler* self = new ( ELeave ) CVtEngDtmfHandler( aH324Config );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop(); // self
    __VTPRINTEXIT( "DTMF.New" )
	return self;
	}

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::~CVtEngDtmfHandler
//
// -----------------------------------------------------------------------------
//
CVtEngDtmfHandler::~CVtEngDtmfHandler()
    {
    __VTPRINTENTER( "DTMF.~" )
    if ( iDtmfStates )
    	{
        iDtmfStates->ResetAndDestroy();
    	}
    delete iDtmfStates;
    if( iProtoDtmf )
        {
        VTProtocolFactory::DeleteUserInputIndication(iProtoDtmf);
        }
    iProtoDtmf = NULL;
    __VTPRINTEXIT( "DTMF.~" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::HandleL
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::HandleL( CVtEngOperation& aOp )
    {
    __VTPRINTENTER( "DTMF.HandleL" )

    const TVtEngCommandId cmdId( aOp.Command() );
    switch ( cmdId )
        {
        case KVtEngStartDtmfTone:
            {
            __VTPRINT( DEBUG_MEDIA , "DTMF. start tone" )
            TChar tone;
            TVtEngOpParamUtil<TChar>::Set( tone, aOp );
            CVtEngDtmfState* state = (*iDtmfStates)[iCurrentState];
            if ( state )
                {
                TVtEngDtmfTone dtmfTone( tone );
                state->SendDtmfL( dtmfTone );
                }
            }
            break;
        case KVtEngStopDtmfTone:
            __VTPRINT( DEBUG_MEDIA , "DTMF. stop tone (no op)" )
            break;
        // Handling of different UIIs
        case KVtEngSetUIIDtmfSupport:
            SetUIISupport( EDTMFString );
            __VTPRINT( DEBUG_MEDIA , "DTMF Support enabled" )
            break;
        case KVtEngSetUIIBasicStringSupport:
            SetUIISupport( EBasicString );
            __VTPRINT( DEBUG_MEDIA , "Basic string Support enabled" )
            break;
        case KVtEngSetUIIIA5StringSupport:
            SetUIISupport( EIA5String );
            __VTPRINT( DEBUG_MEDIA , "IA5 String Support enabled" )
            break;
        case KVtEngSetUIIGeneralStringSupport:
            SetUIISupport( EGeneralString );
            __VTPRINT( DEBUG_MEDIA , "General String Support enabled" )
            break;
        default:
            __VTPRINT( DEBUG_MEDIA , "DTMF.Handle cmd not supported" )
            User::Leave( KErrNotSupported );
        }
    __VTPRINTEXIT( "DTMF.HandleL" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::ActivateState
//
// -----------------------------------------------------------------------------
//
CVtEngDtmfState& CVtEngDtmfHandler::ActivateState( TVtEngDtmfState aNewState )
    {
    __VTPRINTENTER( "DTMF.ActivateState" )
    __VTPRINT2( DEBUG_MEDIA , " new state=%d", aNewState )
    __ASSERT_ALWAYS( aNewState >= EVtDtmfStateIdle &&
        aNewState <= EVtDtmfStateBuffered,
        Panic( EVtEngPanicInvalidDtmfState) );
    iCurrentState = aNewState;
    __VTPRINTEXIT( "DTMF.ActivateState" )
    return *(*iDtmfStates)[iCurrentState];
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::SendComplete
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::SendComplete( TInt aError )
    {
    __VTPRINTENTER( "DTMF.SendComplete" )
#ifdef VTDEBUG
    TRAPD( ignore, HandleSendCompleteL( aError ) );
    __VTPRINT2( DEBUG_MEDIA , "DTMF.SendComplete err=%d", ignore )
#else
    TRAP_IGNORE( HandleSendCompleteL( aError ) );
#endif // VTDEBUG
    __VTPRINTEXIT( "DTMF.SendComplete" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::ProtoDtmf
//
// -----------------------------------------------------------------------------
//
MVTUserInput& CVtEngDtmfHandler::ReserveProtoDtmfL(
    const TVtEngDtmfTone& aTone )
    {
    __VTPRINTENTER( "DTMF.ReserveProtoDtmfL" )
    if ( iProtoDtmf != NULL )
        {
        __VTPRINT( DEBUG_MEDIA , "DTMF.ReserveProtoDtmfL IN USE" )
        User::Leave( KErrInUse );
        }
    TUint8 val = (TUint8) aTone.iTone;

#ifdef VTDEBUG
    if ( CVtLogger::Flags() & CVtLogger::ELogMedia )
        {
        const TChar ch( val );
        _LIT( KVtDtmfBufferTrace, "VT: DTMF. tone value=" );
        TBuf<25> buffer( KVtDtmfBufferTrace() );
        buffer.Append( ch );
        RDebug::Print( buffer );
        }
#endif

    

    // NOTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // IT MUST BE CHECKED IS GIVEN LETTER SUPPORTED BY
    // USED ENCODING SCHEME. NOW WE PASS ONLY NUMBERS AND * AND #
    // AND THEY ARE SAFE TO USE BUT USING POWERFULL UIIs GIVE POSSIBILITY
    // TO SEND ALL DIGITS AND NUMBERS. IN THAT CASE SET OF CHARS MUST BE CHECKED
    // IN VTENGINE. (THAT IS THE REASON WHY THERE IS SEPARATE IF ELSEs)
    // NOTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    __VTPRINT2( DEBUG_MEDIA , "DTMF. Proto USERINPUT %d", iUIISupport )
    switch ( iUIISupport )
        {
        case EBasicString:
        case EIA5String:
        case EGeneralString:
            __VTPRINT( DEBUG_MEDIA , "DTMF. Proto USERINPUT alphanumeric" )
				iProtoDtmf = VTProtocolFactory::CreateUserInputIndication( EVtUiiAlphaNumeric, val );
            break;
        case EDTMFString:
            __VTPRINT( DEBUG_MEDIA , "DTMF. Proto USERINPUT iDTMFString" )
				iProtoDtmf = VTProtocolFactory::CreateUserInputIndication( EVtUiiDTMF, val);
            break;
        default:
            __VTPRINT( DEBUG_MEDIA , "DTMF. Proto USERINPUT unsupported" )
            break;
        }
    __VTPRINTEXIT( "DTMF.ReserveProtoDtmfL" )
    return *iProtoDtmf;
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::ReleaseProtoDtmf
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::ReleaseProtoDtmf()
    {
    __VTPRINTENTER( "DTMF.ReleaseProtoDtmf" )
    if( iProtoDtmf )
        {
        VTProtocolFactory::DeleteUserInputIndication(iProtoDtmf);
        }
    iProtoDtmf = NULL;
    __VTPRINTEXIT( "DTMF.ReleaseProtoDtmf" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::CVtEngDtmfHandler
//
// -----------------------------------------------------------------------------
//
CVtEngDtmfHandler::CVtEngDtmfHandler( MVtH324ConfigCommand& aH324Config ) :
    iCurrentState( EVtDtmfStateIdle ), iH324Config( aH324Config ),
    iUIISupport( EIA5String ), iIssuedDtmfCommandId(KProtoDtmfCommandId)
    {
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::ConstructL
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::ConstructL()
    {
    __VTPRINTENTER( "DTMF.ConstructL" )
    iDtmfStates = new ( ELeave )
        CArrayPtrFlat<CVtEngDtmfState>( DTMF_STATES_COUNT );

    for ( TInt state = EVtDtmfStateIdle;
          state <= EVtDtmfStateBuffered;
          state++ )
        {
        CreateStateL( state );
        }
    __VTPRINTEXIT( "DTMF.ConstructL" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::HandleSendCompleteL
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::HandleSendCompleteL( TInt aError )
    {
    __VTPRINTENTER( "DTMF.HandleSendCompleteL" )

    __VTPRINT2( DEBUG_MEDIA , " HandleSendCompleteL err=%d", aError )
    if ( iDtmfStates )
        {
        CVtEngDtmfState* state = (*iDtmfStates)[iCurrentState];
        if ( state )
            {
            __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL,
                "DTMF. complete on state %d", iCurrentState )
            state->DtmfSendCompleteL( aError );
            }
        }
    __VTPRINTEXIT( "DTMF.HandleSendCompleteL" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::CreateState
//
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::CreateStateL( TInt aState )
    {
    __VTPRINTENTER( "DTMF.CreateStateL" )
    CVtEngDtmfState* dtmfState = NULL;
    switch ( aState )
        {
        case EVtDtmfStateIdle:
            dtmfState = CVtEngDtmfIdle::NewL( *this, iH324Config );
            break;
        case EVtDtmfStateSending:
            dtmfState = CVtEngDtmfSending::NewL( *this, iH324Config );
            break;
        case EVtDtmfStateBuffered:
            dtmfState = CVtEngDtmfBuffered::NewL( *this, iH324Config );
            break;
        default:
            Panic( EVtEngPanicInvalidDtmfState );
            break;
        }
    CleanupStack::PushL( dtmfState );
    iDtmfStates->AppendL( dtmfState );
    CleanupStack::Pop();
    __VTPRINTEXIT( "DTMF.CreateStateL" )
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::GetUIISupport
// returns the current UII support
// -----------------------------------------------------------------------------
//
CVtEngDtmfHandler::TUIISupport CVtEngDtmfHandler::GetUIISupport() const
    {
    __VTPRINT2( DEBUG_MEDIA , "DTMF. GETUSERINPUT support=%d", iUIISupport )
    return iUIISupport;
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::SetUIISupport
// Sets the UII support mode
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::SetUIISupport( CVtEngDtmfHandler::TUIISupport aValue )
    {
    __VTPRINT2( DEBUG_MEDIA , "DTMF. SETUSERINPUT support=%d", aValue )
    iUIISupport = aValue;
    }

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::CheckCommandId
// Compares last issued DTMF command ID to parameter given command ID
// -----------------------------------------------------------------------------
//
TBool CVtEngDtmfHandler::CheckCommandId( TInt aCheckCommandId ) const
	{
	__VTPRINT3( DEBUG_MEDIA , "DTMF. CHKCMID aCheckCommandId=%d iIssuedDtmfCommandId=%d",\
		aCheckCommandId, iIssuedDtmfCommandId )
	
	if( iIssuedDtmfCommandId == aCheckCommandId )
		{
		return ETrue;
		}
	
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CVtEngDtmfHandler::StoreCommandId
// Stores given command ID
// -----------------------------------------------------------------------------
//
void CVtEngDtmfHandler::StoreCommandId( TInt aStoreCommandId )
	{
	__VTPRINT2( DEBUG_MEDIA , "DTMF. STORECOMMANDID aStoreCommandId=%d", aStoreCommandId )
	
	iIssuedDtmfCommandId = aStoreCommandId;			
	}
//  End of File