// Copyright (c) 1997-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 <commsdattypesv1_1.h>

#include <cdblen.h>

#include "ATDIAL.H"

#include "mSLOGGER.H"

#include "PHONE.H"

#include "CALL.H"

#include "ATNOCARR.H"

#include "NOTIFY.H"

#include "ATIO.H"

#include <etelmm.h>

#include "Matstd.h"

const TInt KWaitForConnect=30000; 

CATDialVoice* CATDialVoice::NewL(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	{

	CATDialVoice* dial=new(ELeave) CATDialVoice(aIo, aTelObject, aInit,aPhoneGlobals);

	CleanupStack::PushL(dial);

	dial->ConstructL();		// This ConstructL call is required to allow our base classes to construct

	CleanupStack::Pop();

	return dial;

	}

CATDialVoice::CATDialVoice(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	: CATVoiceCallConnectCommands(aIo,aTelObject,aInit,aPhoneGlobals)

	{}

void CATDialVoice::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams)

	{

	LOGTEXT(_L8("Starting Voice Dial Command"));

	iState=EATInitialising;

	iTelnum=REINTERPRET_CAST(TDesC*,aParams);

	CATVoiceCallConnectCommands::Start(aTsyReqHandle,aParams);

	}

void CATDialVoice::Stop(TTsyReqHandle aTsyReqHandle)

//

//	Attempt to halt the dial process by sending a carriage return, expecting a NO CARRIER

//	message, or if the pre-dial commands are still being sent then simply wait for OK

//

	{

	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle));

	__ASSERT_ALWAYS(iState!=EATNotInProgress,Panic(EATCommand_NotInProgress));		

	LOGTEXT(_L8("Cancelling Voice Dial Command"));

	iIo->WriteAndTimerCancel(this);

	if (iState!=EATInitialising)

		{

		Write(KCarriageReturn(),1);		

		iState = EATCancellingWaitForWriteComplete;

		iPreConnectState=CATCallConnectCommands::ENotInProgress;	

		}

	else

		{

		AddStdExpectStrings(); 

		iPreConnectState=CATCallConnectCommands::ECancelling;

		iState = EATNotInProgress;

		}

	}

TInt CATDialVoice::AddDialExpectStrings()

	{

	LOGTEXT2(_L8("Entered CATDialVoice::AddDialExpectStringsL with iNoDialToneExpectString of %x"),iNoDialToneExpectString);

	AddCommonExpectStrings();

	TInt ret(KErrNone);

	if (!iCallMonitoringExpectString)

		{

			iCallMonitoringExpectString=iIo->AddExpectString(this,KCallMonitoringEventString);

		}

	if (!iBusyExpectString)

		{

		ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameBusy),iBusyString);

		if(ret!=KErrNone)

			return ret;

		AppendWildCardChar(iBusyString);

		iBusyExpectString=iIo->AddExpectString(this,iBusyString);

		}

	if (!iNoDialToneExpectString)

		{

		ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoDialTone),iNoDialToneString);

		if(ret!=KErrNone)

			return ret;

		iNoDialToneExpectString=iIo->AddExpectString(this,iNoDialToneString);

		}

	if (!iNoAnswerExpectString)

		{

		ret=iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoAnswer),iNoAnswerString);

		if(ret!=KErrNone)

			return ret;

		AppendWildCardChar(iNoAnswerString);

		iNoAnswerExpectString=iIo->AddExpectString(this,iNoAnswerString);

		}

	if (!iDelayedExpectString)

		iDelayedExpectString=iIo->AddExpectString(this,KDelayedString);

	LOGTEXT(_L8("Leaving CATDialVoice::AddDialExpectStringsL"));

	return KErrNone;

	}

TInt CATDialVoice::ValidateDialExpectString()

	{

	CCommChatString* foundChatString = iIo->FoundChatString();

	if (foundChatString == iOKExpectString)

		return KErrNone;

	if (foundChatString == iCallMonitoringExpectString)

	{

		LOGTEXT(_L8("Modem returned *ECAV Ericsson Call Monitoring (similar to NO CARRIER) in response to dial command"));

		return KErrEtelNoCarrier;

	}

	if (foundChatString == iNoCarrierExpectString)

		{

		LOGTEXT(_L8("Modem returned NO CARRIER in response to dial command"));

		return KErrEtelNoCarrier;

		}

	if (foundChatString == iNoDialToneExpectString)

		{

		LOGTEXT(_L8("Modem returned NO DIALTONE in response to dial command"));

		return KErrEtelNoDialTone;

		}

	if (foundChatString == iBusyExpectString)

		{

		LOGTEXT(_L8("Modem returned BUSY in response to dial command"));

		return KErrEtelBusyDetected;

		}

	if (foundChatString == iNoAnswerExpectString)

		{

		LOGTEXT(_L8("Modem returned NO ANSWER in response to dial command"));

		return KErrEtelNoAnswer;

		}

	if (foundChatString == iDelayedExpectString)

		{

		LOGTEXT(_L8("Modem returned DELAYED in response to dial command"));

		return KErrEtelBusyDetected;	// No 'Delayed' error message

		}

	LOGTEXT(_L8("Voice dial command\tunexpected match!"));

	return KErrGeneral;

	}

void CATDialVoice::RemoveDialExpectStrings()

	{

	RemoveCommonExpectStrings();

	iIo->RemoveExpectString(iCallMonitoringExpectString);

	iCallMonitoringExpectString=NULL;	// Set pointer to NULL to denote we have removed the expect string

	iIo->RemoveExpectString(iBusyExpectString);

	iBusyExpectString=NULL;			// Set pointer to NULL to denote we have removed the expect string

	iIo->RemoveExpectString(iNoDialToneExpectString);

	iNoDialToneExpectString=NULL;	// Set pointer to NULL to denote we have removed the expect string

	iIo->RemoveExpectString(iNoAnswerExpectString);

	iNoAnswerExpectString=NULL;		// Set pointer to NULL to denote we have removed the expect string

	iIo->RemoveExpectString(iDelayedExpectString);

	iDelayedExpectString=NULL;		// Set pointer to NULL to denote we have removed the expect string

	}

void CATDialVoice::CompleteWithIOError(TEventSource aSource,TInt aStatus)

	{

	if (iState!=EATNotInProgress)

		{

		iState = EATNotInProgress;

		CATCallConnectCommands::CompleteWithIOError(aSource,aStatus);

		}

	}

void CATDialVoice::EventSignal(TEventSource aSource)

	{

	LOGTEXT2(_L8("CATDialVoice::EventSignal with iState %d"),iState);

	if ((aSource==ETimeOutCompletion)&&(iState!=EATCancellingReadCompleted)

		&&(iState!=CATDialVoice::EATNotInProgress)

		&&(iState!=CATDialVoice::EDTRDropped)

		&&(iState!=CATDialVoice::EWaitForDTRRaiseSettle)

		&&(iState!=CATDialVoice::EATHangupReadCompleted))

		{

		LOGTEXT(_L8("Timeout Error during voice Dial"));

		RemoveDialExpectStrings();

		RemoveStdExpectStrings();

		iState = EATNotInProgress;

		Complete(KErrTimedOut,aSource);

		return;

		}

	//

	// Read Completions can happen in unexpected places with the 

	// Ericsson Call Monitoring (AT*ECAM=1) turned on, so need check

	// it outside of the state machine.

	//

	// The Ericsson call monitoring replaces the Ericsson SH888 hack also

	//

	if ((aSource==EReadCompletion))

		{

		// Does it match a General Expect String?

		TInt ret=ValidateExpectString();

		// Not General, so does it match a Dial Specific Expect String?

		if (ret != KErrNone)

			ret=ValidateDialExpectString();

		// It doesn't match any Expect Strings at all, so complete with error

		// otherwise just continue with the state machine as normal

		if (ret != KErrNone)

			{

			LOGTEXT2(_L8("Completing call with Error %d"), ret);

			Complete(ret,aSource);

			return;

			}

		}

	if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted

		&& iPreConnectState!=CATCallConnectCommands::ENotInProgress)

		{

		CATCallConnectCommands::PreConnectEventSignal(aSource);

		if (iPreConnectState==CATCallConnectCommands::ENotInProgress)	// cancelled

			iState=EATNotInProgress;

		if (iPreConnectState!=CATCallConnectCommands::EATInitCompleted)

			return;

		else

			iState=EATSendDialCommand;

		}

	switch(iState)

		{

	case EATSendDialCommand:

		{

		ChangeLineStatus(RCall::EStatusDialling);

		// Setting to EStatusDialling always returns KErrNone

		(void)ChangeCallStatus(RMobileCall::EStatusDialling);

		iPhoneGlobals->iNotificationStore->CheckNotification(REINTERPRET_CAST(CCallBase*,iTelObject),EBegunConnecting);

		TBuf8<KCommsDbSvrMaxFieldLength> dialModifier;

		TInt ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameDialToneWaitModifier),dialModifier);

		if (ret)

			{

			Complete(ret,aSource);

			break;

			}

		TInt len = iTelnum->Length();

		HBufC8* buf = NULL;

		TRAP(ret,buf  = HBufC8::NewL(len));

		if (ret)

			{

			Complete(ret,aSource);

			break;

			}

		TPtr8 newTelnum(buf->Des());

		newTelnum.Copy(*iTelnum);

   		TInt aPos=newTelnum.FindF(dialModifier);

		if (aPos!=KErrNotFound)

			newTelnum.Delete(aPos,1);

		iTxBuffer.Format(KDialVoiceCommandFormat,&newTelnum);

		delete buf;

		iIo->Write(this,iTxBuffer);

		iIo->SetTimeOut(this);

		iState=EATDialWaitForWriteComplete;

		}

		break;

	case EATDialWaitForWriteComplete:

		{

		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		TInt ret=AddDialExpectStrings();

		AddStdExpectStrings();

		if (ret)

			{

			Complete(ret,aSource);

			break;

			}

		iIo->SetTimeOut(this,KWaitForConnect); // 30 seconds for the other end to pick up.

		iState=EATDialReadComplete;

		}

		break;

	case EATDialReadComplete:

		__ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));

			{

			iIo->WriteAndTimerCancel(this);

			RemoveDialExpectStrings();

			RemoveStdExpectStrings();

			iState = EATNotInProgress;

			Complete(KErrNone,aSource);

			}

		break;

	case EATCancellingWaitForWriteComplete:

		{

		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		TInt ret=AddDialExpectStrings();

		if (ret)

			{

			Complete(ret,aSource);

			break;

			}

		if (!iOKExpectString)

			{

			iOKExpectString=iIo->AddExpectString(this,KOkString);

			}

		iIo->SetTimeOut(this);

		iState=EATCancellingReadCompleted;

		}

		break;

	case EATCancellingReadCompleted:

			{

			iState = EATNotInProgress;

			if (aSource==EReadCompletion)

				{

				TInt ret=ValidateDialExpectString();

				RemoveDialExpectStrings();

				iOKExpectString=NULL;

				if (ret==KErrNone)

					{

					iIo->DropDtr();		

					iIo->SetTimeOut(this,KDTRLowPeriod);

					iState=EDTRDropped;

					return;

					}

				}

			RemoveDialExpectStrings();

			Complete(KErrCancel,aSource);

			}

		break;

	case EDTRDropped:

		__ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected));

		iIo->Cancel();

		iIo->RaiseDTR();

		iIo->Read();

		iIo->SetTimeOut(this,KDTRHighSettle);

		iState=EWaitForDTRRaiseSettle;

		break;

	case EWaitForDTRRaiseSettle:

		__ASSERT_ALWAYS(aSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected));

		Write(KHangUpCommand(),1);

		iState=EATHangupWaitForWriteComplete;

		break;

	case EATHangupWaitForWriteComplete:

		__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		if (!iNoCarrierExpectString)

			iNoCarrierExpectString=iIo->AddExpectString(this,KNoCarrierString);

		StandardWriteCompletionHandler(aSource,2);

		iState=EATHangupReadCompleted;

		break;

	case EATHangupReadCompleted:

		__ASSERT_ALWAYS(aSource!=EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteNotExpected));

		Complete(KErrCancel,aSource);

		break;

	default:

		;

		}		

	}

//

// Dial number for data call. Remove the dial modifier W if found and only add it again if the

// call parameters indicate that we are to wait for dial tone.

//

CATDialData* CATDialData::NewL(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	{

	CATDialData* dial=new(ELeave) CATDialData(aIo, aTelObject, aInit,aPhoneGlobals);

	CleanupStack::PushL(dial);

	dial->ConstructL();

	CleanupStack::Pop();

	return dial;

	}

CATDialData::CATDialData(CATIO* aIo, CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

											: CATDataCallConnectCommands(aIo,aTelObject,aInit,aPhoneGlobals)

	{}

void CATDialData::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams)

	{

	LOGTEXT(_L8("Starting ATD Dial Command"));

	iState=EATInitialising;

	iTelnum=REINTERPRET_CAST(TDesC*,aParams);

	CATDataCallConnectCommands::Start(aTsyReqHandle,aParams);

	}

void CATDialData::Stop(TTsyReqHandle aTsyReqHandle)

//

//	Attempt to halt the dial process by sending a carriage return, expecting a NO CARRIER

//	message, or if the pre-dial commands are still being sent then simply wait for OK

//

	{

	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle));

	__ASSERT_ALWAYS(iState!=EATNotInProgress,Panic(EATCommand_NotInProgress));		

	LOGTEXT(_L8("Cancelling ATD Dial Command"));

	if (iState!=EATInitialising)

		{

		iIo->WriteAndTimerCancel(this);

		Write(KCarriageReturn(),1);		

		iState = EATCancellingWaitForWriteComplete;

		iPreConnectState=CATCallConnectCommands::ENotInProgress;	

		}

	else

		{

		AddStdExpectStrings(); 

		iPreConnectState=CATCallConnectCommands::ECancelling;

		iState = EATNotInProgress;

		}

	}

void CATDialData::AddDialExpectStringsL()

	{

	LOGTEXT2(_L8("Entered CATDialData::AddDialExpectStringsL with iNoDialToneExpectString of %x"),iNoDialToneExpectString);

	(void)User::LeaveIfError(AddCommonExpectStrings());

	if (!iBusyExpectString)

		{

		(void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameBusy),iBusyString));

		AppendWildCardChar(iBusyString);

		iBusyExpectString=iIo->AddExpectString(this,iBusyString);

		}

	if (!iNoDialToneExpectString)

		{

		(void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoDialTone),iNoDialToneString));

		iNoDialToneExpectString=iIo->AddExpectString(this,iNoDialToneString);

		}

	if (!iNoAnswerExpectString)

		{

		(void)User::LeaveIfError(iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameNoAnswer),iNoAnswerString));

		AppendWildCardChar(iNoAnswerString);

		iNoAnswerExpectString=iIo->AddExpectString(this,iNoAnswerString);

		}

	if (!iDelayedExpectString)

		iDelayedExpectString=iIo->AddExpectString(this,KDelayedString);

	LOGTEXT(_L8("Leaving CATDialData::AddDialExpectStringsL"));

	}

void CATDialData::ValidateDialExpectStringL()

	{

	CCommChatString* foundChatString = iIo->FoundChatString();

	if (foundChatString == iConnectExpectString)

		{

		return;

		}

	if (foundChatString == iNoCarrierExpectString)

		{

		LOGTEXT(_L8("Modem returned NO CARRIER in response to dial command"));

		User::Leave(KErrEtelNoCarrier);

		}

	if (foundChatString == iNoDialToneExpectString)

		{

		LOGTEXT(_L8("Modem returned NO DIALTONE in response to dial command"));

		User::Leave(KErrEtelNoDialTone);

		}

	if (foundChatString == iBusyExpectString)

		{

		LOGTEXT(_L8("Modem returned BUSY in response to dial command"));

		User::Leave(KErrEtelBusyDetected);

		}

	if (foundChatString == iNoAnswerExpectString)

		{

		LOGTEXT(_L8("Modem returned NO ANSWER in response to dial command"));

		User::Leave(KErrEtelNoAnswer);

		}

	if (foundChatString == iDelayedExpectString)

		{

		LOGTEXT(_L8("Modem returned DELAYED in response to dial command"));

		User::Leave(KErrEtelBusyDetected);	// No 'Delayed' error message

		}

	LOGTEXT(_L8("Data dial command\tunexpected match!"));

	User::Leave(KErrGeneral);

	}

void CATDialData::RemoveDialExpectStrings()

	{

	RemoveCommonExpectStrings();

	iIo->RemoveExpectString(iBusyExpectString);

	iBusyExpectString=NULL;

	iIo->RemoveExpectString(iNoDialToneExpectString);

	iNoDialToneExpectString=NULL;

	iIo->RemoveExpectString(iNoAnswerExpectString);

	iNoAnswerExpectString=NULL;

	iIo->RemoveExpectString(iDelayedExpectString);

	iDelayedExpectString=NULL;

	}

void CATDialData::CompleteWithIOError(TEventSource aSource,TInt aStatus)

	{

	if (iState!=EATNotInProgress)

		{

		iState = EATNotInProgress;

		CATCallConnectCommands::CompleteWithIOError(aSource,aStatus);

		}

	}

void CATDialData::EventSignal(TEventSource aSource)

	{

	LOGTEXT3(_L8("CATDialData::EventSignal with iState:%d aSource:%d"),iState,aSource);

	if(aSource==ETimeOutCompletion)

		{

		if(iState!=EATSpeedReadComplete && iState!=EATCancellingReadCompleted &&

		   iState!=EATNotInProgress &&