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

//

#ifdef USING_CTSY_DISPATCHER

/**

 * This file contains additional function definitions for the CMmDtmfTsy class

 * in CTSY for use when the CTSY is used with the CTSY Dispatcher.

 */

#include "cmmdtmftsy.h"

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmcalllist.h"

#include "cmmcalltsy.h"

#include <ctsy/tflogger.h>

/**

 * Starts sending a single DTMF digit.

 *

 * This version of StartDTMFToneL sends the call ID of the active call through

 * which the DTMF digit will be sent and hence relieves the LTSY of the

 * responsibility to track the call state and to locate the active call.

 *

 * @param aTsyReqHandle The TSY request handle.

 * @param aTone The tone to send.

 * @return Return value to the ETel Server.

 */

TInt CMmDtmfTsy::StartDTMFToneL(const TTsyReqHandle aTsyReqHandle, TChar* aTone)

	{

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

    TInt ret = KErrServerBusy;

    // Check if request handle already exists

    TTsyReqHandle startDtmftoneHandle =

        iMmPhone->iTsyReqHandleStore->GetTsyReqHandle(

            CMmPhoneTsy::EMultimodePhoneStartDTMFTone );

    if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != startDtmftoneHandle)

        {

        iMmPhone->ReqCompleted(aTsyReqHandle, ret);

        }

    else

        {

        // DTMF can only be sent if there is a connected call

        // The call ID for the first connected call found is returned. If there

        // isn't an ongoing conference call, there will only be one active call.

        // If there is a conference call going, the DTMF will be sent using the

        // call ID of one of the active calls in the conference and will be

        // sent through to the conference call.

        TInt callId = -1;

        if (GetConnectedCallId(callId) != KErrNone)

        	{

        	iMmPhone->ReqCompleted(aTsyReqHandle, KErrEtelCallNotActive);

        	}

        else

        	{

	        CMmDataPackage dataPackage;

	        dataPackage.PackData(&callId, aTone);

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

	            EMobilePhoneStartDTMFTone,

	            &dataPackage

	            );

	        if (ret != KErrNone)

	        	{

	        	iMmPhone->ReqCompleted(aTsyReqHandle, ret);

	        	}

	        else

	            {

	            // Save the type of the DTMF

	            iDtmfType = EDtmfTypeDigit;

	            iMmPhone->iReqHandleType =

	                            CMmPhoneTsy::EMultimodePhoneStartDTMFTone;

	            }

        	}

        }

    return KErrNone;

	} // CMmDtmfTsy::StartDTMFToneL

/**

 * Stops sending a single DTMF digit.

 *

 * @param aTsyReqHandle The TSY request handle.

 * @return Return value to the ETel Server.

 */

TInt CMmDtmfTsy::StopDTMFToneL(const TTsyReqHandle aTsyReqHandle)

	{

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

    TInt ret = KErrServerBusy;

    // Check if request handle already exists

    TTsyReqHandle stopDtmftoneHandle =

        iMmPhone->iTsyReqHandleStore->GetTsyReqHandle(

            CMmPhoneTsy::EMultimodePhoneStopDTMFTone );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != stopDtmftoneHandle )

        {

        iMmPhone->ReqCompleted( aTsyReqHandle, ret );

        }

    else

        {

        // DTMF can only be stopped if there is a connected call

        TInt callId = -1;

        if (GetConnectedCallId(callId) != KErrNone)

        	{

        	iMmPhone->ReqCompleted(aTsyReqHandle, KErrEtelCallNotActive);

        	}

        else

        	{

	        CMmDataPackage dataPackage;

	        dataPackage.PackData(&callId);

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

	            EMobilePhoneStopDTMFTone,

	            &dataPackage

	            );

	        if (ret != KErrNone)

	        	{

	        	iMmPhone->ReqCompleted(aTsyReqHandle, ret);

	        	}

	        else

	            {

	            // Save the type of the DTMF

	            iDtmfType = EDtmfTypeDigit;

	            iMmPhone->iReqHandleType =

	                            CMmPhoneTsy::EMultimodePhoneStopDTMFTone;

	            }

        	}

        }

    return KErrNone;

	} // CMmDtmfTsy::StopDTMFToneL

/**

 * Complete the Start DTMF Tone request.

 *

 * @param aResult Error code from LTSY.

 */

void CMmDtmfTsy::CompleteStartDTMFTone(TInt aResult)

	{

	TFLOGSTRING2("TSY: CMmDtmfTsy::CompleteStartDTMFTone aResult=%d", aResult);

    TTsyReqHandle reqHandle

        = iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle(

        		CMmPhoneTsy::EMultimodePhoneStartDTMFTone);

    if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle)

        {

        iMmPhone->ReqCompleted(reqHandle, aResult);

        }

	} // CMmDtmfTsy::CompleteStartDTMFTone

/**

 * Complete the Stop DTMF Tone request.

 *

 * @param aResult Error code from LTSY.

 */

void CMmDtmfTsy::CompleteStopDTMFTone(TInt aResult)

	{

	TFLOGSTRING2("TSY: CMmDtmfTsy::CompleteStopDTMFTone aResult=%d", aResult);

    TTsyReqHandle reqHandle

        = iMmPhone->iTsyReqHandleStore->ResetTsyReqHandle(

        		CMmPhoneTsy::EMultimodePhoneStopDTMFTone);

    if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle)

        {

        iMmPhone->ReqCompleted(reqHandle, aResult);

        }

	} // CMmDtmfTsy::CompleteStopDTMFTone

/**

 * Send a DTMF string passing down the call ID of the connected call to LTSY.

 * @param aTsyReqHandle The TSY request handle.

 * @param aTones

 * @return

 */

TInt CMmDtmfTsy::SendDTMFTonesL(const TTsyReqHandle aTsyReqHandle, const TDesC* aTones)

	{

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

    TTsyReqHandle sendDTMFTonesHandle = iMmPhone->iTsyReqHandleStore

        ->GetTsyReqHandle(CMmPhoneTsy::EMultimodePhoneSendDTMFTones);

    if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown == sendDTMFTonesHandle)

        {

        // DTMF can only be sent if there is a connected call

        TInt callId = -1;

        if (GetConnectedCallId(callId) != KErrNone)

        	{

        	iMmPhone->ReqCompleted(aTsyReqHandle, KErrEtelCallNotActive);

        	}

        else

        	{

	        CMmDataPackage dataPackage;

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

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

	            EMobilePhoneSendDTMFTones,

	            &dataPackage

	            );

	        if (ret != KErrNone)

	            {

	            // DTMF string sending has failed

	            iMmPhone->ReqCompleted(aTsyReqHandle, ret);

	            }

	        else

	            {

    	        iDtmfType = EDtmfTypeString;

	            iMmPhone->iReqHandleType = CMmPhoneTsy::EMultimodePhoneSendDTMFTones;

	            }

        	}

        } // if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown == sendDTMFTonesHandle)

    else

    	{

    	iMmPhone->ReqCompleted(aTsyReqHandle, KErrServerBusy);

    	}

    return KErrNone;

	} // CMmDtmfTsy::SendDTMFTonesL

/**

 * Locate an active voice call.

 *

 * @param aCallId The call ID of an active call, if there is one.

 * @return KErrNone if it finds an active call, KErrNotFound otherwise.

 */

TInt CMmDtmfTsy::GetConnectedCallId(TInt& aCallId)

	{

	CMmCallTsy* mmCall = iMmPhone->CallList()->GetMmCallByStatus(RMobileCall::EStatusConnected);

	if (mmCall)

		{

		aCallId = mmCall->CallId();

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	} // CMmDtmfTsy::GetConnectedCallId

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

// CMmDtmfTsy::Complete

// Completes the request due timer expiration. Adds a timeout for start

// and stop of DTMF.

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

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

//

void CMmDtmfTsy::Complete(TInt aReqHandleType, TInt)

    {

    switch (aReqHandleType)

        {

        case CMmPhoneTsy::EMultimodePhoneSendDTMFTones:

            CompleteSendDTMFTones(KErrTimedOut);

            break;

        case CMmPhoneTsy::EMultimodePhoneStartDTMFTone:

        	CompleteStartDTMFTone(KErrTimedOut);

        	break;

        case CMmPhoneTsy::EMultimodePhoneStopDTMFTone:

        	CompleteStopDTMFTone(KErrTimedOut);

        	break;

        default:

            // Ignore

            break;

        }

    } // CMmDtmfTsy::Complete

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

// CMmDtmfTsy::SendDTMFTonesCancelL

// Cancels DTMF tone sending passing down the call ID.

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

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

//

TInt CMmDtmfTsy::SendDTMFTonesCancelL()

    {

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

    TTsyReqHandle sendDTMFTonesHandle =

        iMmPhone->iTsyReqHandleStore->GetTsyReqHandle(

            CMmPhoneTsy::EMultimodePhoneSendDTMFTones );

    // There must be a pending Send to cancel

    if (CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != sendDTMFTonesHandle)

        {

		TInt callId = -1;

		// There needs to be a connected call to send the cancel through

		// If there isn't do nothing

		if (GetConnectedCallId(callId) == KErrNone)

			{

			// no packed parameter for DOS call

			CMmDataPackage dataPackage;

			dataPackage.PackData(&callId);

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

					EMobilePhoneSendDTMFTonesCancel,

					&dataPackage);

			if ( KErrNone == ret )

				{

				// Set the DTMFTonesCancelFlag

				iSendDTMFTonesCancelFlag = ETrue;

				}

			}

        }

    return KErrNone;

	}

#endif // USING_CTSY_DISPATCHER