// Copyright (c) 2006-2009 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:

//

//INCLUDE FILES

#include "cmmdtmftsy.h"

#include <etelmmcs.h> 

#include <ctsy/tflogger.h> 

// include internal Tsy classes

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmcalltsy.h"

#include "cmmcalllist.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

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

CMmDtmfTsy::CMmDtmfTsy()

    {

    }

void CMmDtmfTsy::ConstructL()

    {

    iSendDTMFTonesCancelFlag = EFalse;

    iDtmfType = EDtmfTypeUnknown;

    //register dtmf tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject(

        CMmMessageManagerBase::EDtmfTsy, this );

    }

CMmDtmfTsy* CMmDtmfTsy::NewL(

    CMmPhoneTsy* aPhoneTsy ) // Pointer to PhoneTsy

    {

    CMmDtmfTsy* self = new ( ELeave ) CMmDtmfTsy;

    // this cannot leave:

    self->iMmPhone = aPhoneTsy;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CMmDtmfTsy::~CMmDtmfTsy()

    {

    TFLOGSTRING("TSY: CMmDtmfTsy::~CMmDtmfTsy");

    if (iMmPhone )

        {

        // deregister tsy object from message manager

        iMmPhone->MessageManager()->DeregisterTsyObject(this);        

        }

    iMmPhone = NULL;

    iDTMFStringToContinue.Zero();

    iRetDtmfCaps = NULL;

    }

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

// CMmDtmfTsy::DoExtFuncL

// DTMF-specific functionality of CMmPhoneTsy::DoExtFuncL

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::DoExtFuncL( 

	const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc, 

    const TDataPackage& aPackage )  

    {

    TInt ret = KErrNone;

    TAny* dataPtr = aPackage.Ptr1();

    TBool cont ( EFalse );

    switch ( aIpc )

        {

        // supported DTMF features

        // Get DTMF Caps

        case EMobilePhoneGetDTMFCaps:

        	ret = GetDTMFCaps( aTsyReqHandle, 

            reinterpret_cast<TUint32*>( dataPtr ) );

            break;	

        // Notify Change of DTMF Capabilities

        case EMobilePhoneNotifyDTMFCapsChange:

        	ret = NotifyDTMFCapsChange( 

            reinterpret_cast<TUint32*>( dataPtr ) );

            break;	

        // Send DTMF Tones 

        case EMobilePhoneSendDTMFTones:

            ret = SendDTMFTonesL( aTsyReqHandle, aPackage.Des1u() );

            break;

        // Start DTMF Tone

        case EMobilePhoneStartDTMFTone:

            ret = StartDTMFToneL( aTsyReqHandle,

            reinterpret_cast<TChar*>( dataPtr ) );

            break;	

        // Stop DTMF Tone

        case EMobilePhoneStopDTMFTone:

            ret = StopDTMFToneL( aTsyReqHandle );

            break;	

        // Notify Stop in DTMF String

        case EMobilePhoneNotifyStopInDTMFString:

            ret = NotifyStopInDTMFString();

            break;	

        // Continue or Stop DTMF String Sending

        case EMobilePhoneContinueDTMFStringSending:

            cont = * ( reinterpret_cast<TBool*>( dataPtr ) );

            ret = ContinueDTMFStringSendingL( aTsyReqHandle, cont );

            break;

        case EMobilePhoneNotifyDTMFEvent:

            ret = NotifyDTMFEvent( reinterpret_cast<TInt*>( dataPtr ) );

	    	break;	

		// not supported DTMF features

		case EMobilePhoneReadDTMFTones:

            ret = KErrNotSupported;

            break;	

        // error case

        default:

            // this method should only be called for DTMF cases

            ret = KErrArgument;

            break;	

        }

    return ret;

    }

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

// CMmDtmfTsy::NotifyDtmfEvent

// Request for Notification of DTMF event received from client. 

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

TInt CMmDtmfTsy::NotifyDTMFEvent( TInt* aInfo )

	{

TFLOGSTRING("TSY: CMmDtmfTsy::NotifyDTMFEvent");

	iDtmfInfo = aInfo; // save pointer to client data

	// save handle type

	iMmPhone->iReqHandleType = CMmPhoneTsy::EMultimodePhoneNotifyDtmfEvent;

	return KErrNone;

	}

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

// CMmDtmfTsy::CompleteNotifyDtmfEvent

// Notifies client that a DTMF event has occurred. 

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

//

void CMmDtmfTsy::CompleteNotifyDTMFEvent( TInt aInfo )

     {

TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyDtmfEvent");

    // reset request handle. Returns the deleted req handle.

	TTsyReqHandle reqHandle =	

		iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

    					CMmPhoneTsy::EMultimodePhoneNotifyDtmfEvent );

    // check if request was called

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        *iDtmfInfo = aInfo;

        iDtmfInfo=NULL;

        iMmPhone->ReqCompleted( reqHandle, KErrNone );

        }

    }

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

// CMmDtmfTsy::NotifyDTMFEventCancel

// Cancels a notification request. 

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

TInt CMmDtmfTsy::NotifyDTMFEventCancel( const TTsyReqHandle aTsyReqHandle )

    {

TFLOGSTRING("TSY: CMmDtmfTsy::NotifyDtmfEventCancel");

	iDtmfInfo = NULL;

	TTsyReqHandle reqHandle =	

	iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

					CMmPhoneTsy::EMultimodePhoneNotifyDtmfEvent );

	iMmPhone->ReqCompleted( aTsyReqHandle, KErrCancel );

	return KErrNone;

    }

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

// CMmDtmfTsy::CancelService

// Cancels DTMF requests.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::CancelService(   

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle ) 

    {

    TInt ret ( KErrNotSupported );

    TInt trapError = KErrNone;

    switch ( aIpc )

        {

        case EMobilePhoneNotifyDTMFCapsChange:

            ret = NotifyDTMFCapsChangeCancel( aTsyReqHandle );

            break;	

        case EMobilePhoneNotifyStopInDTMFString:

            ret = NotifyStopInDTMFStringCancel( aTsyReqHandle );

            break;	

        case EMobilePhoneSendDTMFTones:

            // Note: it is silently ignored if SendDTMFTonesCancelL

            // leaves here (it's just a cancellation)

            TRAP( trapError, 

                ret = SendDTMFTonesCancelL();

                );

            if ( KErrNone != trapError )

                {

                return trapError;

                }

            break;

		case EMobilePhoneNotifyDTMFEvent:

			ret = NotifyDTMFEventCancel(aTsyReqHandle);

			break;

        // error case

        default:

            // this method should only be called for DTMF cases

            ret = KErrArgument;

            break;	

        }

    return ret;

    }

#ifndef USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::Complete

// Completes the request due timer expiration.

// (other items were commented in a header).

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

//

void CMmDtmfTsy::Complete(

    TInt aReqHandleType, 

    TInt ) 

    {

    switch( aReqHandleType )

        {

        // there is only one DTMF case with a defined timeout

        case CMmPhoneTsy::EMultimodePhoneSendDTMFTones:

            CompleteSendDTMFTones( KErrTimedOut );

            break;	

        default:

            // ignore

            break;

        }

    }

#endif // USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::GetDtmfType

// Returns value of internal attribute iDtmfType.

// (other items were commented in a header).

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

//

CMmDtmfTsy::TDtmfType CMmDtmfTsy::GetDtmfType()

    {

    return iDtmfType;

    }

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

// CMmDtmfTsy::GetDTMFCaps

// This function returns the DTMF capabilities of the phone in 

// the aCaps parameter. The DTMF capabilities can change 

// dynamically for example when the call becomes active or is 

// closed.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::GetDTMFCaps(

    const TTsyReqHandle aTsyReqHandle, // Tsy request handle

    TUint32* aCaps ) // on return, contains the capabilities 

    {

    //Set initial value for capabilities

    *aCaps = 0;

    //Get the number of active Calls in list of calls

    TInt count = ActiveCalls();

    //Search the Calls in call list and check if at least one call is active

    if(count > 0)

        {

        *aCaps = RMobilePhone::KCapsSendDTMFString |

            RMobilePhone::KCapsSendDTMFSingleTone;

        }

    // Complete the request

    iMmPhone->ReqCompleted( aTsyReqHandle, KErrNone );

    return KErrNone;

    }

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

// CMmDtmfTsy::NotifyDTMFCapsChange

// This function is used to request notifications about changes 

// in DTMF capabilities.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::NotifyDTMFCapsChange(

    TUint32* aCaps ) 

    {

    iRetDtmfCaps = aCaps;

    iMmPhone->iReqHandleType = CMmPhoneTsy::EMultimodePhoneNotifyDTMFCaps;

    return KErrNone;

    }

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

// CMmDtmfTsy::NotifyDTMFCapsChangeCancel

// Cancels DTMF capabilities notification request.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::NotifyDTMFCapsChangeCancel(

    const TTsyReqHandle aTsyReqHandle ) 

    {

    iRetDtmfCaps = NULL;

    iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneNotifyDTMFCaps );

    iMmPhone->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmDtmfTsy::CompleteNotifyDTMFCaps

// Notifies client about changes in DTMF capabilities if the 

// client has requested DTMF change notifications.

// (other items were commented in a header).

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

//

void CMmDtmfTsy::CompleteNotifyDTMFCaps()

    {

    //reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle 	

        = iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneNotifyDTMFCaps );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {        

        GetDTMFCaps( reqHandle, iRetDtmfCaps );

        iRetDtmfCaps = NULL;

        iMmPhone->ReqCompleted( reqHandle, KErrNone );

        }

    }

#ifndef USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::SendDTMFTonesL

// Sends burst DTMF tones. The DTMF tones to be sent are given

// in the parameter and the DTMF string can contain one or more DTMF

// characters.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::SendDTMFTonesL(   

    const TTsyReqHandle aTsyReqHandle, // Request handle

    const TDesC* aTones ) // DTMF tone string to be sent

    {

    if( aTones->Length() == 0 )

        {

        return KErrArgument;

        }

    if( aTones->Length() > KDtmfStringMaxLength)

        {

        return KErrArgument;

        }

    //check if handle is not in use already

    TTsyReqHandle sendDTMFTonesHandle = iMmPhone->iTsyReqHandleStore

        ->GetTsyReqHandle( CMmPhoneTsy::EMultimodePhoneSendDTMFTones );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown == sendDTMFTonesHandle )

        {

        // packed parameter for DOS call: tones

        // Check if there is an active call

        if(ActiveCalls() == 0)

            {

            return KErrEtelCallNotActive;

            }

        CMmDataPackage dataPackage;

        dataPackage.PackData( const_cast<TDesC*>( aTones ) );

        TInt ret = iMmPhone->MessageManager()->HandleRequestL(

            EMobilePhoneSendDTMFTones, 

            &dataPackage

            );

        // Save the type of the DTMF

        iDtmfType = EDtmfTypeString;

        if ( KErrNone != ret )

            {

            // DTMF string sending has failed

            iMmPhone->ReqCompleted( aTsyReqHandle, ret );

            }

        else

            {

            iMmPhone->iReqHandleType =

                CMmPhoneTsy::EMultimodePhoneSendDTMFTones;

            }

        return KErrNone;

        }

    else

        {

        return KErrServerBusy;

        }

    }

#endif // #ifndef USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::CompleteSendDTMFTones

// This function should be called when DTMF string has been sent to

// the network. The function completes SendDTMFTones request to the 

// client.

// (other items were commented in a header).

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

//

void CMmDtmfTsy::CompleteSendDTMFTones( 

     TInt aResult ) // error code

    {

    // Get req handle. 

    TTsyReqHandle reqHandle = iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneSendDTMFTones );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        iDTMFStringToContinue.Zero();

        iMmPhone->ReqCompleted( reqHandle, aResult );

        }

    }

#ifndef USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::SendDTMFTonesCancelL

// Cancels DTMF tone sending.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::SendDTMFTonesCancelL()

    {

TFLOGSTRING("TSY: CMmDtmfTsy::SendDTMFTonesCancel");

    TTsyReqHandle sendDTMFTonesHandle =

        iMmPhone->iTsyReqHandleStore->GetTsyReqHandle( 

            CMmPhoneTsy::EMultimodePhoneSendDTMFTones );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != sendDTMFTonesHandle )

        {

        // no packed parameter for DOS call

        CMmDataPackage dummyPackage;

        TInt ret = iMmPhone->MessageManager()->HandleRequestL( 

            EMobilePhoneSendDTMFTonesCancel, 

            &dummyPackage

            );

        if ( KErrNone == ret )

            {

            // Set the DTMFTonesCancelFlag

            iSendDTMFTonesCancelFlag = ETrue;

            }

        }

    return KErrNone;

    }

#endif // USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::CompleteSendDTMFTonesCancel

// Complete cancel of sending DTMF tones.

// (other items were commented in a header).

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

//

void CMmDtmfTsy::CompleteSendDTMFTonesCancel( 

    TInt aResult ) 

    {

TFLOGSTRING("TSY: CMmDtmfTsy::CompleteSendDTMFTonesCancel");

    // Get req handle. 

    TTsyReqHandle reqHandle = iMmPhone->iTsyReqHandleStore->GetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneSendDTMFTones );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        // If cancel has not succeeded, just discard the message.

        if ( iSendDTMFTonesCancelFlag )

            {

            // Cancel has succeeded. Complete original request and 

            // reset handle

            iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle( 

                CMmPhoneTsy::EMultimodePhoneSendDTMFTones ); 

            iMmPhone->ReqCompleted( reqHandle, KErrCancel );

           	}

        else

            {

            CompleteSendDTMFTones( aResult );

            }

        }

    }

#ifndef USING_CTSY_DISPATCHER

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

// CMmDtmfTsy::StartDTMFToneL

// This function starts a single DTMF tone sending. The tone 

// is played until it is stopped using StopDTMFTone method.

// (other items were commented in a header).

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

//

TInt CMmDtmfTsy::StartDTMFToneL(

    const TTsyReqHandle aTsyReqHandle,

    TChar* aTone ) 

    {

    TInt ret = KErrServerBusy;

    // Check if request handle already exists

    TTsyReqHandle startDtmftoneHandle =