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

// \file mnetwork.cpp

// Basic GSM Network and Operator information Implementation file.

// This file contains the implementation of the CATNetworkInfo, CATDetectNetwork,

// CNotifyNetworkRegistrationStatusChange and CCurrentNetworkChangedNotify classes.

// Find the current Network Operator in Numeric, Long and Short formats.

// NB - Some phones do not fully support all the formats, if any. The commands are 

// sent in sequence starting with the query command (AT+COPS?). All the phones currently

// supported implement this command. Valid responses are set in the TMobilePhoneLocationAreaV1

// and the TMobilePhoneNetworkInfoV1 structures and the Network's status is set to Current.

// 

//

#include <et_phone.h>

#include "mnetwork.h"

#include "mSLOGGER.H"

#include "ATIO.H"

#include "Matstd.h"

#include "mPHONE.H"

const TInt KSettlingPause=1;	//< This pause is used at the end of the network information queries.  The Nokia 8210 has been shown to require this, if it is not to error the next command.

_LIT8(KSetAndReadOperatorCommandNumeric, "AT+COPS=3,2;+COPS?\r");

_LIT8(KSetAndReadOperatorCommandShort, "AT+COPS=3,1;+COPS?\r");

_LIT8(KSetAndReadOperatorCommandLong, "AT+COPS=3,0;+COPS?\r");

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

_LIT8(KOperatorResponse,"+COPS:");

_LIT8(KDetectNetworkCommand,"AT+COPS=?");

static TInt NetworkIdL(const TDesC8& aCode,

					   RMobilePhone::TMobilePhoneNetworkCountryCode& aCountryCode, 

					   RMobilePhone::TMobilePhoneNetworkIdentity& aNetworkIdentity)

	{

/**

 * Utility function to translate the 5 digit ASCII network identification returned by the ME

 * into Mobile Country Code (aCountryCode) and a Mobile Network Code (aNetworkIdentity) strings.

 * Tbe format returned by the ME is XXXYY, where XXX represents the Mobile Country Code and YY

 * represents the Mobile Network Code.

 */

	if (aCode.Length()!=5)

		{

		return KErrGeneral;

		}

	aCountryCode.SetLength(3);

	aCountryCode[0] = aCode[0];

	aCountryCode[1] = aCode[1];

	aCountryCode[2] = aCode[2];

	aNetworkIdentity.SetLength(2);

	aNetworkIdentity[0] = aCode[3];

	aNetworkIdentity[1] = aCode[4];

	return KErrNone;

	}

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

/**

 * Standard two-phase constructor.

 */

	{

	CATNetworkInfo* netInfo = new(ELeave) CATNetworkInfo(aIo, aTelObject, aInit, aPhoneGlobals);

	CleanupStack::PushL(netInfo);

	netInfo->ConstructL();

	CleanupStack::Pop();

	return netInfo;

	}

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

	: CATCommands(aIo,aTelObject,aInit,aPhoneGlobals)

	,iPhoneGlobals(aPhoneGlobals)

	{}

CATNetworkInfo::~CATNetworkInfo()

/**

 * Standard Destructor.

 * Note the NULLing of the iATNetworkInfo pointer.  This should prevent any unwanted calling

 * of this function from the "end of command" sequence after the class' destruction.

 */

	{

	iIo->RemoveExpectStrings(this);

	iPhoneGlobals->iATNetworkInfo=NULL;

	}

void CATNetworkInfo::Start(TTsyReqHandle aTsyReqHandle,TAny* aParam)

/**

 * This is the standard entry point for retrieving the Network Information.

 */

	{

	LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tStarting Operator Info."));

	iReqHandle = aTsyReqHandle;

	if (aParam!=NULL)

		{

		TTsyNetworkInfo* info = static_cast<TTsyNetworkInfo*>(aParam);

		iNetworkInfo.iNetworkInfoPckg = info->iNetworkInfoPckg;

		iNetworkInfo.iArea = info->iArea;

		}

	//

	// This object is not always started thru the CATBase::ExecuteCommand

	// So we sometimes have to manually control the flow control of iEventSignalActive

	iPhoneGlobals->iEventSignalActive = ETrue;

	iCancelled=EFalse;

	if (iReqHandle==0)

		iTelObject->FlowControlSuspend();

	StartGetOperator();

	}

void CATNetworkInfo::CheckOperator()

/**

 * This function is called whenever an EventSignal Completes.  It is a second entry point for the command.

 * It checks CPhoneGlobals iPhoneStatus.iNetworkChanged and calls this function if it detects that the

 * networking information has changed and therefore the CPhoneGlobals data may be out of date and needs

 * to be refreshed.

 */

	{

	Start(0,0);

	}

void CATNetworkInfo::EventSignal(TEventSource aSource)

/**

 * This function contains the state machine for the command.  The states flow consecutively and are

 * described below.

 * 

 * \par EATGetCurrentOperatorWriteComplete

 * Wait for the "AT+COPS?" write to complete

 *

 * \par EATGetCurrentOperatorReadComplete

 * Parse the "AT+COPS?" response.  If it gets an "ERROR" back it assume that no COPS commands are

 * supported, so complete the request with an error.  If it is supported, parse the result and proceed

 * to retrieve the numeric network code with "AT+COPS=3,2;+COPS?"

 *

 * \par EATNumericOperatorWaitForWriteComplete

 * Wait for the "AT+COPS=3,2;+COPS?" to complete

 *

 * \par EATSetNumericOperatorReadComplete

 * Parse the numeric network code if available.  Proceed to retrieve the short network code with

 * "AT+COPS=3,1;+COPS?".

 *

 * \par EATShortOperatorWaitForWriteComplete

 * Wait for the "AT+COPS=3,1;+COPS?" write to complete.

 *

 * \par EATSetShortOperatorReadComplete

 * Parse the short network name if available.  Proceed to retrieve the long network name with

 * "AT+COPS=3,0;+COPS?".

 *

 * \par EATLongOperatorWaitForWriteComplete

 * Wait for the "AT+COPS=3,0;+COPS?" write to complete.

 *

 * \par EATSetLongOperatorReadComplete

 * Parse the long network name if available.  Proceed to complete the request. 

 * Check for outstanding current network operator notifications at this point. 

 *

 * \par EATWaitForStopState

 * This state is used when stopping the state machine to ensure that a pending modem response has been

 * retrieved before freeing up the Multimode TSY to send more commands.  Prematurely stopping the state machine

 * is usually forced by a client cancel request.

 *

 * \par EATWaitForSettlingTimeout

 * This state is used to provide a pause at the end of the network information queries. The Nokia 8210

 * has been shown to require this, if it is not to arbitrarily error the next command.

 */

	{

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

		{

		LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tTimeout Error during Operator read"));

		RemoveStdExpectStrings();

		Complete(KErrTimedOut,aSource);

		return;

		}

	switch(iState)

		{

		case EATGetCurrentOperatorWriteComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			StandardWriteCompletionHandler(aSource, 5);

			iState=EATGetCurrentOperatorReadComplete;

			}

			break;

		case EATGetCurrentOperatorReadComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			TInt ret(ValidateExpectString());

			RemoveStdExpectStrings();

			if (ret != KErrNone)

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\t+COPS? not supported"));

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tSet Operator Command not supported")); // An assumption

				Complete(ret, aSource);	// No point in sending the Set Command.

				}

			else if (iCancelled)

				{

				Complete(KErrCancel, aSource);	// Cancel state machine in safe place

				}

			else

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\t+COPS? supported"));

				TRAPD(ret,ParseOperatorResponseL());

				if (ret != KErrNone)

					{

					LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tError parsing +COPS?"));

					}								

				iTxBuffer.Copy(KSetAndReadOperatorCommandNumeric); // AT+COPS=3,2;+COPS?

				iIo->Write(this, iTxBuffer);

				iIo->SetTimeOut(this, 5000);

				iState=EATNumericOperatorWaitForWriteComplete;

				}

			}

			break;		

		case EATNumericOperatorWaitForWriteComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			StandardWriteCompletionHandler(aSource, 5);

			iState=EATSetNumericOperatorReadComplete;

			}

			break;

		case EATSetNumericOperatorReadComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			TInt ret(ValidateExpectString());

			RemoveStdExpectStrings();

			if (iCancelled)

				{

				Complete(KErrCancel, aSource);	// Cancel state machine in safe place

				return;

				}

			else if (ret != KErrNone) 

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tAT+COPS=3,2 not supported"));				

				}				

			else	// Set Operator Command was successful, Read the Current Operator

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\t	AT+COPS=3,2 supported"));

				TRAPD(ret,ParseOperatorResponseL());

				if (ret != KErrNone)

					{

					LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tError parsing +COPS=3,2"));

					}					

				}

			iTxBuffer.Copy(KSetAndReadOperatorCommandShort); // AT+COPS=3,1;+COPS?

			iIo->Write(this, iTxBuffer);

			iIo->SetTimeOut(this, 5000);

			iState=EATShortOperatorWaitForWriteComplete; 

			}

			break;

		case EATShortOperatorWaitForWriteComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			StandardWriteCompletionHandler(aSource, 5);

			iState=EATSetShortOperatorReadComplete;

			}

			break;

		case EATSetShortOperatorReadComplete:

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

				{

				iIo->WriteAndTimerCancel(this);

				TInt ret(ValidateExpectString());

				RemoveStdExpectStrings();

				if (iCancelled)

					{

					Complete(KErrCancel, aSource);	// Cancel state machine in safe place

					return;

					}

				else if (ret != KErrNone)

					{

					LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tAT+COPS=3,1 not supported"));					

					}

				else// Set Operator Command was successful, Read the Current Operator

					{	

					LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\t	AT+COPS=3,1 supported"));

					TRAPD(ret,ParseOperatorResponseL());

					if (ret != KErrNone)

						{

						LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tError parsing +COPS=3,1"));

						}						

					}

				iTxBuffer.Copy(KSetAndReadOperatorCommandLong); // AT+COPS=3,0;+COPS?

				iIo->Write(this, iTxBuffer);

				iIo->SetTimeOut(this, 5000);

				iState=EATLongOperatorWaitForWriteComplete; 

				}

			break;

		case EATLongOperatorWaitForWriteComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			StandardWriteCompletionHandler(aSource, 5);

			iState=EATSetLongOperatorReadComplete;

			}

			break;

		case EATSetLongOperatorReadComplete:

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

			{

			iIo->WriteAndTimerCancel(this);

			TInt ret(ValidateExpectString());

			RemoveStdExpectStrings();

			if (ret != KErrNone)

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\t+COPS=3,0 not supported"));

				}

			else	// Set Operator cmd was successful, Read the Current Operator

				{

				LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tAT+COPS=3,0 supported"));

				TRAPD(ret,ParseOperatorResponseL());

				if (ret != KErrNone)

					{

					LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tError parsing +COPS=3,0"));

					}						

				}

			// Check outstanding current network operator notifications

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

			iIo->SetTimeOut(this, KSettlingPause*1000);

			iState=EATWaitForSettlingTimeout;

			}

			break;

		case EATWaitForSettlingTimeout:

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

			Complete(KErrNone,aSource);

			break;

		case EATWaitForStopState:

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

			{

			iIo->WriteAndTimerCancel(this);

			Complete(KErrCancel, aSource);

			}

			break;

		default:

			break;

		}//switch

	}//EventSignal

void CATNetworkInfo::Stop(TTsyReqHandle aTsyReqHandle)

/**

 * This function is used to prematurely stop the state machine.  This would usually occur following a

 * client cancel request.

 */

{

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

	LOGTEXT(_L8("MMTsy:\tCATNetworkInfo:\tCancel called."));

	iCancelled=ETrue;

}

void CATNetworkInfo::Complete(TInt aError,TEventSource aSource)

/**

 * This function completes the client's request.

 */

	{

	iIo->WriteAndTimerCancel(this);

	iIo->RemoveExpectStrings(this);

	iOKExpectString = NULL;

	iErrorExpectString = NULL;

	if (aSource==EWriteCompletion)

		iIo->Read();

	iState = EATNotInProgress;

	LOGTEXT2(_L8("MMTsy:CATNetworkInfo:\tCATNetworkInfo completed with error code : %d"), aError);

	//

	// BEWARE: The next command will be started from inside ReqCompleted or FlowControlResume

	// 

	//

	// This object is not always started thru the CATBase::ExecuteCommand

	// So we sometimes have to manually control the flow control of iEventSignalActive

	iPhoneGlobals->iEventSignalActive = EFalse;

	if (iReqHandle)

		{

		// Explicit call from a client

		if (aError==KErrNone)

			{

			GetCurrentNetworkInfo(&iNetworkInfo); 

			}

		iTelObject->ReqCompleted(iReqHandle, aError);

		}

	else

		{

		// CheckOperator() call from CATCommands::Complete

		iTelObject->FlowControlResume();

		}

	CATCommands::Complete(aError,aSource);

	}

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

/**

 * This function handles I/O errors that may occur during any of the stages of the state machine.

 */

	{

	if (iState!=EATNotInProgress)

		{

		iIo->WriteAndTimerCancel(this);

		if (iReqHandle)

			{

			iTelObject->ReqCompleted(iReqHandle, aStatus);

			}

		else

			{

			// CheckOperator() call from CATCommands::Complete

			iTelObject->FlowControlResume();

			}

		iState = EATNotInProgress;

		}

	}

void CATNetworkInfo::StartGetOperator()

/**

 * This function kicks off the state machine by transmitting the first command, "AT+COPS?" and

 * setting the state.

 */

	{

	iPhoneGlobals->iPhoneStatus.iNetworkChanged=EFalse;

	InitializeNetworkInfo();		// Initialize the TNetworkInfo struct that will contain the mobile's responses

	iTxBuffer.Copy(KGetCurrentOperatorCommand);

	iIo->Write(this, iTxBuffer);

	iIo->SetTimeOut(this, 5000);

	iState=EATGetCurrentOperatorWriteComplete;

	}

void CATNetworkInfo::InitializeNetworkInfo()

/**

 * This function is used to initialize (to zero) the network information elements in the CPhoneGlobals

 * structure.

 */

	{

	RMobilePhone::TMobilePhoneNetworkInfoV1& networkinfo = iPhoneGlobals->iPhoneStatus.iCurrentNetwork;

	networkinfo.iMode = RMobilePhone::ENetworkModeUnknown;

	networkinfo.iCountryCode.Zero();		// Unknown, MCC

	networkinfo.iNetworkId.Zero();			// MNC

	networkinfo.iCdmaSID.Zero();			// Unused CDMA field

	networkinfo.iAnalogSID.Zero();			// Unused CDMA field

	networkinfo.iShortName.Zero();

	networkinfo.iLongName.Zero();

	networkinfo.iStatus = RMobilePhone::ENetworkStatusUnknown; 

	networkinfo.iDisplayTag.Zero();

	}

void CATNetworkInfo::ParseOperatorResponseL()

/**

 * This function is used to parse the ME responses to commands to retrieve numeric, short name 

 * or long name network information.  Possible responses are:

 * +COPS: mode, 0, "long format name"

 * +COPS: mode, 1, "short format name"

 * +COPS: mode, 2, "operator ID in hex"

 * +COPS: mode  (no network information available)

 *

 * Relevant information is retrieved and written into the CPhoneGlobals class.

 */

	{

	RMobilePhone::TMobilePhoneNetworkInfoV1& networkInfo = iPhoneGlobals->iPhoneStatus.iCurrentNetwork; 

	ParseBufferLC();	// Parse the buffer and create a linked list with the phone's response

	CATParamListEntry* entry;

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	// The 1st item in the list should be the +COPS: response

	entry=iter++;

	if (entry && entry->iResultPtr.MatchF(KOperatorResponse)!=0)

		User::Leave(KErrGeneral);

	// The next item is the mode (this information is not used)

	entry=iter++;

	if (!entry)

		User::Leave(KErrGeneral);  

	// The next item should be the format. If there is no network information then this item

	// would be empty. The network status is consequently updated.

	entry=iter++;

	if (!entry)  // Not connected, so the response is "+COPS: 0"

		networkInfo.iStatus=RMobilePhone::ENetworkStatusUnknown;

	else	

		{

		TInt format=CATParamListEntry::EntryValL(entry);

		// If the format is available, the network name is the next item in the list 

		entry=iter++;

		if (!entry)

			User::Leave(KErrGeneral);

		switch (format)

			{

		case 0:

			if((entry->iResultPtr).Length() > networkInfo.iLongName.MaxLength())

				networkInfo.iLongName.Copy((entry->iResultPtr).Mid(0,networkInfo.iLongName.MaxLength()));			

			else

				networkInfo.iLongName.Copy(entry->iResultPtr);

			break;

		case 1:

			if((entry->iResultPtr).Length() > networkInfo.iShortName.MaxLength())

				networkInfo.iShortName.Copy((entry->iResultPtr).Mid(0,networkInfo.iShortName.MaxLength()));			

			else 

				networkInfo.iShortName.Copy(entry->iResultPtr);	

			break;

		case 2:

			User::LeaveIfError(NetworkIdL(entry->iResultPtr,networkInfo.iCountryCode, networkInfo.iNetworkId));