// Copyright (c) 2001-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:
// Implements the functionality required to provide DMTF transmission services.
// 
//

/**
 @file
*/

#include <testconfigfileparser.h>
#include "CSimDtmf.h"
#include "CSimPhone.h"
#include "CSimVoiceCall.h"
#include "Simlog.h"

const TInt KPauseDuration=2;		//< The duration of a "pause" DTMF character.
const TInt KDtmfToneDuration=3;		//< The duration of a standard DTMF character (tone or "pause").

CSimDtmf* CSimDtmf::NewL(CSimPhone* aPhone)
/**
 * Standard two-phase constructor.
 * @param aPhone		The parent phone object.
 * @return CSimDtmf		The new signal strength class.
 */
	{
	CSimDtmf* self=new(ELeave) CSimDtmf(aPhone);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CSimDtmf::CSimDtmf(CSimPhone* aPhone)
		: iPhone(aPhone)
/**
 * Trivial first phase construction.
 * @param aPhone	The parent phone object.
 */
	{
	}

void CSimDtmf::ConstructL()
/**
 * Second phase construction.  Create instances of the necessary heap-based
 * objects and read in the DTMF information from the configuration file.
 *
 * Entries in the configuration file will take the following format:
 * "XXX= <Yyy>, <Zzz>"
 * A number of these entries may be included to create a signal strength profile
 * for the duration of the test.
 */
	{
	iTimer=CSimTimer::NewL(iPhone);
	}

CSimDtmf::~CSimDtmf()
/**
 * Standard destructor.  Destroy the heap-based object owned by this object.
 */
	{
	delete iDtmfData;
	delete iTimer;
	}

TInt CSimDtmf::GetDtmfCaps(TTsyReqHandle aReqHandle,TDes8* aPckg1)
/**
 * Retrieve DMTF capability information.  This function completes the
 * client's request synchronously.
 *
 * @param aReqHandle	The request handle associated with this request.
 * @param aPckg1		The first parameter package.  This will be populated with the
 *						capability data to be returned.
 * @return TInt			Standard error value.
 */
	{
	TPckg<TUint32>* dtmfCapsPckg=(TPckg<TUint32>*)aPckg1;
	TUint32& dtmfCaps=(*dtmfCapsPckg)();

	dtmfCaps= RMobilePhone::KCapsSendDTMFString |
			  RMobilePhone::KCapsSendDTMFSingleTone;
	iPhone->ReqCompleted(aReqHandle,KErrNone);
	return KErrNone;
	}

TInt CSimDtmf::NotifyDtmfCapsChange(TTsyReqHandle /*aReqHandle*/,TDes8* /*aPckg1*/)
/**
 * Register a client's interest in being notified when the DMTF Caps change.
 * Since the capabilities remain static, this request is not completed.
 *
 * @param aReqHandle	The handle associated with this request.
 * @param aPckg1		The first parameter package.  This is populated with the changed
 *						capability information.
 * @return TInt			Standard error value.
 */
	{
	return KErrNone;
	}

void CSimDtmf::NotifyDtmfCapsChangeCancel(TTsyReqHandle aReqHandle)
/**
 * Cancel a previous request to be notified of a change in DTMF capabilities.
 */
	{
	iPhone->ReqCompleted(aReqHandle,KErrCancel);
	}

TInt CSimDtmf::SendDTMFTones(TTsyReqHandle aReqHandle,TDes* aPckg1)
/**
 * Send a series of DMTF tones.
 *
 * @param aReqHandle	The request handle associated with this request.
 * @param aPckg1		The first parameter package.  This will be populated with the
 *						DTMF tone data to be sent.
 * @return TInt			Standard error value.
 */
	{
	TInt ret=SetDtmfCall();
	if(ret!=KErrNone)
		{
		iPhone->ReqCompleted(aReqHandle,KErrEtelCallNotActive);
		return KErrNone;
		}

	if(aPckg1->Length()==0)
		{
		iPhone->ReqCompleted(aReqHandle,KErrNone);
		return KErrNone;
		}

	iDtmfData=HBufC::New(aPckg1->Length());
	if(iDtmfData==NULL)
		{
		iPhone->ReqCompleted(aReqHandle,KErrNoMemory);
		return KErrNone;
		}
	iDtmfData->Des().Copy(*aPckg1);

	iDtmfString=ETrue;
	iDtmfStringIndex=0;
	iDtmfStringReqPending=aReqHandle;
	ret=ActionEvent(EEventStartDtmfString,(*iDtmfData)[iDtmfStringIndex]);
	if(ret!=KErrNone)
		{
		CompleteDtmfStringTx(ret);
		}
	return KErrNone;
	}

TInt CSimDtmf::StartDTMFTone(TTsyReqHandle aReqHandle,TDes8* aPckg1)
/**
 * Send a single DMTF tone.
 *
 * @param aReqHandle	The request handle associated with this request.
 * @param aPckg1		The first parameter package.  This will be populated with the
 *						DTMF tone to be sent.
 * @return TInt			Standard error value.
 */
	{
	TInt ret=SetDtmfCall();
	if(ret!=KErrNone)
		{
		iPhone->ReqCompleted(aReqHandle,KErrEtelCallNotActive);
		return KErrNone;
		}

	TPckg<TChar>* tonePckg=(TPckg<TChar>*)aPckg1;
	TChar& tone=(*tonePckg)();

	ret=ActionEvent(EEventStartDtmfTone,tone);
	iPhone->ReqCompleted(aReqHandle,ret);
	return KErrNone;
	}

TInt CSimDtmf::StopDTMFTone(TTsyReqHandle aReqHandle)
/**
 * Stop transmission of a single DMTF tone.
 *
 * @param aReqHandle	The request handle associated with this request.
 * @return TInt			Standard error value.
 */
	{
	__ASSERT_ALWAYS(CheckForActiveVoiceCall(),SimPanic(EIllegalDtmfReq));
	TInt ret=ActionEvent(EEventStopDtmfTone);
	iPhone->ReqCompleted(aReqHandle,ret);
	return KErrNone;
	}

TInt CSimDtmf::NotifyStopInDTMFString(TTsyReqHandle aReqHandle)
/**
 * Register a client's interest in being notified of when a stop tone is reached.
 * @param aReqHandle	The request handle associated with this request.
 * @return TInt			Standard error value.
 */
	{
	__ASSERT_ALWAYS(!iNotifyStopChar,SimPanic(EIllegalDtmfEvent));
	iNotifyStopChar=ETrue;
	iNotifyStopReqHandle=aReqHandle;
	return KErrNone;
	}

void CSimDtmf::NotifyStopInDTMFStringCancel()
/**
 * Cancel a client's interest in being notified of when a stop tone is reach.
 */
	{
	if(iNotifyStopChar)
		{
		iNotifyStopChar=EFalse;
		iPhone->ReqCompleted(iNotifyStopReqHandle,KErrCancel);
		}
	}

TInt CSimDtmf::ContinueDtmfStringSending(TTsyReqHandle aReqHandle,TDes8* aPckg1)
/**
 * Continue transmitting a DTMF String after a wait character has been hit.
 * @param aPckg1		The first request package, which contains an indication of
 *						whether the request should be continued.
 * @param aReqHandle	The request handle associated with this request.
 * @return TInt			Standard error value.
 */
	{
	if(!CheckForActiveVoiceCall())
		{
		iPhone->ReqCompleted(aReqHandle,KErrNotReady);
		return KErrNone;
		}

	TPckg<TBool>* contPckg=(TPckg<TBool>*)aPckg1;
	TBool& cont=(*contPckg)();

	if(cont)
		{
		TInt ret=ActionEvent(EEventContinueDtmf);
		iPhone->ReqCompleted(aReqHandle,ret);
		}
	else
		{
		TInt ret=ActionEvent(EEventTerminateDtmf);
		iPhone->ReqCompleted(aReqHandle,ret);
		}
	return KErrNone;
	}

TInt CSimDtmf::ActionEvent(TEvent aEvent)
/**
 * Shell function for events that don't pass a DTMF tone character.
 * @param aEvent	The event to be actioned.
 * @return TInt		Standard error return.
 */
	{
	const TChar KNullChar(0);
	return ActionEvent(aEvent,KNullChar);
	}

TInt CSimDtmf::ActionEvent(TEvent aEvent,const TChar& aTone)
/**
 * Action a DTMF event.
 * @param aEvent	The event to be actioned.
 * @param aTone		Optionally, a tone associated with the event.
 * @return TInt		Standard error return.
 */
	{
	TInt ret = KErrNone;
	switch(aEvent)
		{
	case EEventStartDtmfString:
		if(iState==ETxTone)
			return KErrInUse;
		ret = ProcessTone(aTone,ETrue);
		return ret;

	case EEventStartDtmfTone:
		if(iState==ETxTone)
			return KErrInUse;
		ret = ProcessTone(aTone,EFalse);
		return ret;

	case EEventTimer:
		__ASSERT_ALWAYS(iState==ETxTone,SimPanic(EIllegalDtmfEvent));
		__ASSERT_ALWAYS(iDtmfString,SimPanic(EIllegalDtmfEvent));
		LOGMISC1("Completed sending DTMF Tone");
		iDtmfStringIndex++;
		if(iDtmfStringIndex<iDtmfData->Length())
			ret = ProcessTone((*iDtmfData)[iDtmfStringIndex],ETrue);
		else
			{
			iState=EIdle;
			CompleteDtmfStringTx(KErrNone);
			}
		return ret;

	case EEventStopDtmfTone:
		if(iDtmfString)
			return KErrInUse;
		if(iState!=ETxTone)			// If there's been no StartDtmfTone, then return an error.
			return KErrUnknown;
		LOGMISC1("Stopping DTMF Tone");
		iState=EIdle;
		return KErrNone;

	case EEventContinueDtmf:
		if(iState!=EStopped)
			return KErrUnknown;
		__ASSERT_ALWAYS(iDtmfString,SimPanic(EIllegalDtmfEvent));
		LOGMISC1("Continuing Transmitting a DTMF string after a wait");
		iDtmfStringIndex++;
		if(iDtmfStringIndex<iDtmfData->Length())
			ret = ProcessTone((*iDtmfData)[iDtmfStringIndex],ETrue);
		else
			{
			iState=EIdle;
			CompleteDtmfStringTx(KErrNone);
			}
		return ret;

	case EEventTerminateDtmf:
		if(iState==EStopped)
			{
			__ASSERT_ALWAYS(iDtmfString,SimPanic(EIllegalDtmfEvent));
			iState=EIdle;
			CompleteDtmfStringTx(KErrAccessDenied);
			return KErrNone;
			}
		else
			return KErrUnknown;
	case EEventCallClosure:
		if(iDtmfString)
			{
			iTimer->Cancel();
			CompleteDtmfStringTx(KErrEtelNoCarrier);
			}
		iState=EIdle;
		return KErrNone;
		}

	SimPanic(EIllegalDtmfEvent);
	return KErrNone;		// Dummy to stop compiler error.
	}

/**
Process a tone, i.e. check the tone's validity and, if necessary, start the timer.

@param aTone The DTMF character to be processed.
@param aStartTimer  A flag indicating whether the timer should be started.
                    The timer is not required for the single DTMF tone transmissions.
@return TInt Standard error return.
*/
TInt CSimDtmf::ProcessTone(const TChar& aTone, TBool aStartTimer)
	{
	const TChar wait('w');
	const TChar pause('p');

	if(aTone==wait)
		{
		LOGMISC1("Starting to perform a DTMF wait; character w");
		iState=EStopped;
		CheckNotification();
		return KErrNone;
		}
	else if(aTone.IsDigit()||(aTone>='A')&&(aTone<='D'))
		{
		LOGMISC2("Starting to send DTMF Tone %c", TUint(aTone));
		iState=ETxTone;
		if(aStartTimer)
			{
			iTimer->Start(KDtmfToneDuration,this);
			}
		return KErrNone;
		}
	else if(aTone==pause)
		{
		if(!aStartTimer)
			{
			return KErrArgument;  // can't tx a single "pause" character
			}
		LOGMISC1("Starting to perform a DTMF pause; character p");
		iState=ETxTone;
		iTimer->Start(KPauseDuration,this);
		return KErrNone;
		}
	return KErrArgument;			// Illegal DTMF character.
	}

void CSimDtmf::CompleteDtmfStringTx(TInt aStatus)
/**
 * Complete a DTMF string transmission.
 * @param aStatus	Completion value.
 */
	{
	iDtmfString=EFalse;
	delete iDtmfData;
	iDtmfData=NULL;
	iPhone->ReqCompleted(iDtmfStringReqPending,aStatus);
	}

void CSimDtmf::CheckNotification()
/**
 * If pending, complete a DTMF "wait" command notification.
 */
	{
	if(iNotifyStopChar)
		{
		iNotifyStopChar=EFalse;
		iPhone->ReqCompleted(iNotifyStopReqHandle,KErrNone);
		}
	}

TInt CSimDtmf::SetDtmfCall()
/**
 * Set a pointer to this class in the active voice call class, so that the call class
 * can callback if the call becomes inactive.
 * @return TInt		Standard error return.
 */
	{
	CSimVoiceCall* call;
	TInt ret=iPhone->FindActiveVoiceCall(call);
	if(ret!=KErrNone)
		return ret;
	call->SetDtmfSession(this);
	return ret;
	}

TBool CSimDtmf::CheckForActiveVoiceCall()
/**
 * Check the active call DTMF pointer is pointing to this class.
 * @return TBool	ETrue if the call's pointer is correctly set.  EFalse if not.
 */
	{
	CSimVoiceCall* call;
	TInt ret=iPhone->FindActiveVoiceCall(call);
	if(ret!=KErrNone)
		return EFalse;
	if(call->GetDtmfSession()==this)
		return ETrue;
	return EFalse;
	}


void CSimDtmf::TimerCallBack(TInt /*aId*/)
/**
 * The timer callback function.  This function will be called when the timer
 * completes.  It indicates a DTMF tone completion.  So, the action event function
 * is called to advance the class' state.
 *
 * @param aId	This parameter is unused.  It is only required for CSimXxx classes
 *				that have more than one timer instance and need to identify which
 *				timer has expired.
 */
	{
	TInt ret=ActionEvent(EEventTimer);
	__ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalDtmfEvent));
	}

void CSimDtmf::CallClosureCallback()
	{
	TInt ret=ActionEvent(EEventCallClosure);
	__ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalDtmfEvent));
	}

const CTestConfigSection* CSimDtmf::CfgFile()
/**
 * Returns a pointer to the current configuration file section.
 *
 * @return CTestConfigSection	A pointer to the current configuration file section.
 */
	{
	return iPhone->CfgFile();
	}

void CSimDtmf::SendDTMFTonesCancel()
/**
Cancels pending SendDTMFTone
*/
	{
	iState=EIdle;
	if(iTimer->Running())
		iTimer->Cancel();
	CompleteDtmfStringTx(KErrCancel);
	
	}