// 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:

// AT Initialisation

// 

//

#include <commsdattypesv1_1.h>

#include <cdblen.h>

#include "ATINIT.H"

#include "NOTIFY.H"

#include "mSLOGGER.H"

#include "PHONE.H"

#include "CALL.H"

#include "ATNOCARR.H"

#include "mPHBOOK.H"

#include "ATIO.H"

#include "Matstd.h"

#include "ATHANGUP.H"

#include <etelqos.h>

_LIT8(KTestPhoneBookStorage,"AT+CPBS=?");

_LIT8(KSetExtendedCallIndicationCommand,   "AT+CRC=1\r");

_LIT8(KClearUnsolicitedNetworkRegistration, "AT+CREG=0\r");

_LIT8(KSetUnsolicitedNetworkRegistration2,  "AT+CREG=2\r");

_LIT8(KSetUnsolicitedNetworkRegistration1,  "AT+CREG=1\r");

_LIT8(KReadUnsolicitedNetworkRegistration,  "AT+CREG?\r");

_LIT8(KGetCurrentOperatorCommand, "AT+COPS?\r");

_LIT8(KGetBatteryInfoCommand, "AT+CBC\r");

_LIT8(KGetSignalInfoCommand, "AT+CSQ\r");

_LIT8(KOperatorResponse,"+COPS:");

_LIT8(KGetServiceCentreAddressCommand,"AT+CSCA?\r");

_LIT8(KSetUnsolicitedGPRSNetworkRegistration1,  "AT+CGREG=1\r");

_LIT8(KSetECAMConfigCommand, "AT*ECAM=1\r");

_LIT(KSpaceSeparator," ");

_LIT8(KClassA,"A");

_LIT8(KClassB,"B");

_LIT8(KClassC,"C");

_LIT8(KClassCG,"CG");

_LIT8(KClassCC,"CC");

_LIT16(KEricsson,"*ERICSSON*");

const TInt KMaxNoRetries=3;

const TUint KZeroChar='0';

const TUint KOneChar='1';

#ifdef __LOGDEB__

_LIT8(KLogEntry,"CATInit::%S\t%S");

#define LOCAL_LOGTEXT(function,text) {_LIT8(F,function);_LIT8(T,text);LOGTEXT3(KLogEntry,&F,&T);}

#else

#define LOCAL_LOGTEXT(function,text)

#endif

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

	{

	CATInit* self = new(ELeave) CATInit(aIo,aTelObject,aPhoneGlobals);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

	: CATBase(aIo,aTelObject,aPhoneGlobals)

	{}

void CATInit::ConstructL()

	{

	iEnumerate = CATSmsMemoryStorage::NewL(iIo, iTelObject, this, iPhoneGlobals);

	}

CATInit::~CATInit()

	{

	iIo->RemoveExpectStrings(this);

	delete iEnumerate;

	}

void CATInit::StartInit(CATCommands* aPendingCommand,TTsyReqHandle aTsyReqHandle, TAny* aParams)

	{

	SetToNotInitialised();	

	iPendingCommand = aPendingCommand;

	iReqHandle = aTsyReqHandle;

	iParams = aParams;

	iCallInfo = aPendingCommand->CallInfo();	// iCallInfo is NULL if 

												// aPendingCommand has no iCallInfo

	iIo->Cancel();

	iAttemptCnt=1;

	InitAttempt();

	}

TBool CATInit::CheckActiveReqHandle(const TTsyReqHandle aTsyReqHandle)

//

// Check the Request against the current request handle

//

	{

	if((iPhoneGlobals->iPhoneStatus.iInitStatus==EPhoneInitialising)&&

	   (aTsyReqHandle==iReqHandle))

		return ETrue;

	else

		return EFalse;

	}

void CATInit::StopInit(TTsyReqHandle aTsyReqHandle)

	{

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

	LOGTEXT(_L8("Cancelling Initialisation"));

	iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneInitialiseCancelling;

	iIo->SetTimeOut(this,KOneSecondPause);

	}

void CATInit::SpecialStart(TTsyReqHandle aTsyReqHandle)

//

//	If aTsyReqHandle is NULL, this is an Automatic Init with no ReqComplete to call

//	Otherwise it is from CPhoneHayes::ControlledInitialise() which should be completed

//

	{

	iReqHandle = aTsyReqHandle;

	iPendingCommand = NULL;

	iAttemptCnt=1;

	InitAttempt();

	}

void CATInit::InitAttempt()

	{

	if (iPhoneGlobals->iPhoneStatus.iInitStatus == EPhoneInitialiseCancelling)

		return;	// "initialise" may have been cancelled while we were waiting for the call back.

	LOGTEXT2(_L8("Starting Initialisation Sequence, Attempt %d"),iAttemptCnt);

	iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneInitialising;

	iPhoneGlobals->iSmsPduModeSupported=EFalse;

	TCommConfig aConfigPckg;

	iIo->Cancel();

	TInt ret = iPhoneGlobals->iConfiguration->PortConfig(aConfigPckg,EConfigTypePreInit);

	if (ret==KErrNone)

		ret = iIo->ConfigurePort(aConfigPckg);

	if (ret)

		{

		Complete(ret);

		return;

		}

	iIo->SetTimeOut(this,100);

	iState=EShortTimeOutFix;

	}

void CATInit::RetryOrFail(TBool aCommsErrorOccurred)

	{

	if (!aCommsErrorOccurred)

		iIo->RemoveExpectStrings(this);	

	iConnectExpectString = NULL;

	iNoCarrierExpectString = NULL;

	iOKExpectString = NULL;

	iErrorExpectString = NULL;

	if(++iAttemptCnt > (TUint)KMaxNoRetries)

		{

		LOGTEXT(_L8("Cannot Initialise"));

		iIo->RemoveExpectStrings(this);

		if (iPhoneGlobals->iPhoneStatus.iModemDetected != RPhone::EDetectedPresent)

			Complete(KErrEtelModemNotDetected);

		else

			Complete(KErrEtelInitialisationFailure);

		}

	else

		{

		iIo->Cancel();

		InitAttempt();

		}	

	}

void CATInit::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)

//

//	CATIO removes expect strings in the event of an error from the port, so set ptrs to NULL.

//	If error is KErrCommsFrame and this is the first attempt at initialising, give the modem

//	benefit of the doubt and try again.

//

	{

	if (aStatus==KErrCommsFrame && iAttemptCnt==1)

		RetryOrFail(ETrue);

	else

		{

		iNoCarrierExpectString = NULL;

		iConnectExpectString = NULL;

		iOKExpectString = NULL;

		iErrorExpectString = NULL;

		Complete(aStatus);

		}

	}

void CATInit::ValidateATHExpectStringL()

	{

	if(iIo->FoundChatString()==iErrorExpectString)

		{

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

		User::Leave(KErrGeneral);

		}

	if(iIo->FoundChatString()==iNoCarrierExpectString)

		{

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

		return;

		}

	if(iIo->FoundChatString()==iOKExpectString)

		return;

	LOGTEXT(_L8("Modem returned unexpected response to command"));

	User::Leave(KErrUnknown);

	}

void CATInit::EventSignal(TEventSource aSource)

	{

	if(aSource==ETimeOutCompletion && iState==EWaitForDSR)

		{

		LOGTEXT(_L8("CATInit::EventSignal  Ignoring timeout during EWaitForDSR"));

		iIo->WriteAndTimerCancel(this);

 		iIo->RemoveExpectStrings(this);

		}

	else if ((aSource==ETimeOutCompletion)

	  &&(iPhoneGlobals->iPhoneStatus.iInitStatus != EPhoneInitialiseCancelling)

	  &&(iState!=EATWaitForATCheckOK)&&(iState!=EShortTimeOutFix))

		{

		LOGTEXT(_L8("CATInit::EventSignal  Error during Initialisation Sequence"));

		RetryOrFail();

		return;

		}

	if (iPhoneGlobals->iPhoneStatus.iInitStatus == EPhoneInitialiseCancelling)

		{

		if (aSource==EWriteCompletion)

			{

			iIo->SetTimeOut(this,KOneSecondPause);

			}

		if (aSource==EReadCompletion || aSource==ETimeOutCompletion)

			{

			LOGTEXT2(_L8("Entered InitCancelling with aSource=%d"),aSource);

			iIo->WriteAndTimerCancel(this);

			iIo->RemoveExpectStrings(this);

			iOKExpectString=NULL;

			iErrorExpectString=NULL;

			iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneNotInitialised;

			if (iPendingCommand)

				{

				if (iCallInfo)

					REINTERPRET_CAST(CCallHayes*,iPendingCommand->Owner())->SetToIdle();

				iPendingCommand->Owner()->ReqCompleted(iReqHandle,KErrCancel);

				iPendingCommand=NULL;

				}

			else

				{

				iTelObject->ReqCompleted(iReqHandle,KErrCancel);

				return;

				}

			if ((iCallInfo != NULL) && (iCallInfo->iClientPanicOccurred!=ENoPanicOccurred))

				{

				__ASSERT_DEBUG(iPendingCommand!=NULL,Panic(ERelinquishOwnershipWithNoCall));

				iComplete = CCompleteRelinquish::New(iPendingCommand->Owner());

				iComplete->SetWhichCompletion(iCallInfo->iClientPanicOccurred);

				iComplete->Call();	// calls the AysncOneShot Relinquish completion function

				iCallInfo->iClientPanicOccurred = ENoPanicOccurred;

				}	

			}

		return;

		}

	switch(iState)

		{

	case EShortTimeOutFix:

		//

		//	Calling iIo->Start() synchronously inside the InitAttempt() function caused a 

		//  hang when using IrDA on the ARM, and Netdial, as Netdial is in the ESock thread

		//  and is blocking waiting for its RTelSubSession::Open() to complete, but iIo->Start()

		//	calls C32 which calls ESock. So introduced this short time out.

		//

		//	Also retrieving the strings here at the start of the initialisation - the first

		//	time we get back KErrAccessDenied for some reason.

		//

		{

		iIo->Cancel();

		iIo->Start(this);		// ramps up DTR

		iIo->SetTimeOut(this,5 * KOneSecondPause);	// should be enough time for a battery-powered

													// modem to initialise itself

		__ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral));

		iState=EWaitForDSR;

		}

		break;

	case EWaitForDSR:

 		// Do not assert aSource==EWriteCompletion as we could have got here with a ETimeOutCompletion

		{

		if (!(iIo->ReadPending()))		// Otherwise CATIO will queue a read on the way back down the stack anyway

			iIo->Read();

		Write(KAT2Command(),5);		// needs to be long because IR takes a while 

		iState=EWaitForATHangUpWriteComplete;

		}

		break; //ATHcommand is now an AT. Introduced 23/03/99: Fix ER5-defect EDNJWAD-465K6M

	case EWaitForATHangUpWriteComplete:

		StandardWriteCompletionHandler(aSource,5);

		if (!iNoCarrierExpectString)

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

		iState=EWaitForATHangUpOK;

		break;

	case EWaitForATHangUpOK:

		{

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

		// Fix defect CLE-4RGN8Z, NM, 9/01/01.

		// Fix defect SIH-4UCMW9, that actually fixes the problem caused by

		// previous CLE-4RGN8Z fix !  KAS 2/03/01 

		if (iPhoneGlobals->iPhoneStatus.iModemDetected != RPhone::EDetectedPresent) 

			{

			iPhoneGlobals->iNotificationStore->CheckNotification(iTelObject,EPhoneDetected);

			iPhoneGlobals->iPhoneStatus.iModemDetected = RPhone::EDetectedPresent;

			}

		TRAPD(ret,ValidateATHExpectStringL());

		if (ret)

			{

			RetryOrFail();

			break;

			}

		iIo->WriteAndTimerCancel(this);

		RemoveStdExpectStrings();

		iIo->RemoveExpectString(iConnectExpectString);

		iConnectExpectString = NULL;

		iIo->RemoveExpectString(iNoCarrierExpectString);

		iNoCarrierExpectString=NULL;

		TCommConfig aConfigPckg;

		iIo->Cancel();

		ret = iPhoneGlobals->iConfiguration->PortConfig(aConfigPckg,EConfigTypeInit);

		if (ret==KErrNone)

			ret = iIo->ConfigurePort(aConfigPckg);

		if (ret)

			{

			Complete(ret);

			return;

			}

		//

		// iCallInfo is NULL if this hasn't been originated by a CCallHayes command,

		// eg using CPhoneHayes::Init()

		//

		// Don't bother notifying about hook change here as it's likely only to be from 

		// unknown to on.

		//

		iPhoneGlobals->iNotificationStore->CheckNotification(iTelObject,EBecomeIdle);

		REINTERPRET_CAST(CPhoneHayes*,iTelObject)->SetHookStatus(RCall::EHookStatusOn);

		iPhoneGlobals->iPhoneStatus.iMode = RPhone::EModeIdle;

		TBuf8<KMaxLengthOfUserDefinedInitString> initCommand;

			initCommand=KAT2Command;			

		Write(initCommand,5);

		iState=EWaitForModemInitWrite;

		}

		break;

	case EWaitForModemInitWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EWaitForModemInitOK;

		break;

	case EWaitForModemInitOK:

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

			{

			TInt ret(ValidateExpectString());

			if (ret)

				{

				RetryOrFail();

				break;

				}

			RemoveStdExpectStrings();

			iIo->WriteAndTimerCancel(this);	

			TPtrC8 atCheck(KAT2Command);		// modem may take time to complete user-defined

											// Init string, so send an AT once and if this

											// fails try again twice

			Write(atCheck,5);

			iState=EWaitForATCheckWrite;

			}

		break;

	case EWaitForATCheckWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EATWaitForATCheckOK;

		break;

	case EATWaitForATCheckOK:

		{

		if (aSource==ETimeOutCompletion)

			{

			RemoveStdExpectStrings();

			if (iRetryCounter++ == (TUint)KMaxNoChecks)

				{

				iRetryCounter=0;

				Complete(KErrTimedOut);

				}

			else

				{

				TPtrC8 atCheck(KAT2Command);

				Write(atCheck,5);

				iState=EWaitForATCheckWrite;

				}

			return;

			}

		TInt ret(ValidateExpectString());

		if (ret)

			{

			RetryOrFail();

			break;

			}

		RemoveStdExpectStrings();

		WriteExpectingResults(KGetPhoneCapsCommand(),5);

		iState=EWaitForATGetPhoneCapsWrite;

		}

		break;

	case EWaitForATGetPhoneCapsWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EWaitForATGetPhoneCapsOK;

		break;

	case EWaitForATGetPhoneCapsOK:

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

			{

			TInt ret(ValidateExpectString());

			if(ret==KErrGeneral)

				ParseAnErroredPhoneCaps();

			else if(ret!=KErrNone)

				{	

				RetryOrFail();

				break;

				}

			else

				{

				iIo->WriteAndTimerCancel(this);

				TRAP(ret,ParsePhoneCapsL());

				if (ret)

					{	

					iIo->RemoveExpectStrings(this);

					Complete(KErrEtelInitialisationFailure);

					break;

					}

				}

			RemoveStdExpectStrings();

			TBuf8<KCommsDbSvrMaxFieldLength> echoSetting;

			TBuf8<KCommsDbSvrMaxFieldLength> quietSetting;

			TBuf8<KCommsDbSvrMaxFieldLength> verboseSetting;

			ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameEchoOff),echoSetting);

			if (ret==KErrNone)

				{

				ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameQuietOff),quietSetting);

				}

			if (ret==KErrNone)

				{

				ret = iPhoneGlobals->iConfiguration->ConfigModemString(TPtrC(KCDTypeNameVerboseText),verboseSetting);

				}

			if (ret)

				{

				iIo->RemoveExpectStrings(this);

				Complete(ret);

				break;

				}

			iTxBuffer.Format(_L8("AT%S%S%S\r"),&echoSetting, &quietSetting, &verboseSetting);

			iIo->Write(this,iTxBuffer);

			iIo->SetTimeOut(this,5*KOneSecondPause);

			iState=EWaitForATStandardInitWrite;

			}

		break;

	case EWaitForATStandardInitWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EWaitForATStandardInitOK;

		break;

	case EWaitForATStandardInitOK:

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

			{

			TInt ret(ValidateExpectString());

			if (ret)

				{

				RetryOrFail();

				break;

				}

			iIo->WriteAndTimerCancel(this);

			RemoveStdExpectStrings();

			TPtrC8 interrogateWaitTime(KSmsSetTABufferMode);

			WriteExpectingResults(interrogateWaitTime,5);

			iState=EWaitForATUnsolicitedFixWrite;

			}

		break;

	case EWaitForATUnsolicitedFixWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EWaitForATUnsolicitedFixOK;

		break;

	case EWaitForATUnsolicitedFixOK:

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

			{

			// Ensures that unsolicited messages are buffered by the TA during initialisation

			// We dont care what this returns becasue if AT+CNMI= fails, it is unlikely

			// that SMS's can received at all.

			iIo->WriteAndTimerCancel(this);

			RemoveStdExpectStrings();

			TPtrC8 interrogateWaitTime(KGetCarrierWaitTimeCommand);

			WriteExpectingResults(interrogateWaitTime,5);

			iState=EWaitForATCarrierWaitTimeWrite;

			}

		break;

	case EWaitForATCarrierWaitTimeWrite:

		StandardWriteCompletionHandler(aSource,5);

		iState=EWaitForATCarrierWaitTimeOK;

		break;

	case EWaitForATCarrierWaitTimeOK: