// 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:
// This file provides the implementation of the class for
// the SUPL MT-LR procedure state handler
// 
//

/**
 @file
 @internalTechnology
 @deprecated
*/

#include "suplmtlrfsmsession.h"
#include "suplmtlrstatehandler.h"
#include "suplgatewayinterface.h"
#include "suplmessagebase.h"
#include "suplstart.h"
#include "suplpos.h"
#include "suplposinit.h"
#include "suplresponse.h"
#include "suplend.h"
#include <etelmm.h>
#include "supldevloggermacros.h"


/** Static constructor.
@param aMachine A reference to the parent state machine.
@return A new instance of the CSuplMtLrStateHandler class
*/
CSuplMtLrStateHandler* CSuplMtLrStateHandler::NewL(CSuplFsmSessionBase& aMachine)
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::NewL() \n");
	CSuplMtLrStateHandler* self = new (ELeave) CSuplMtLrStateHandler(aMachine);
	return self;
	}

/** Standard constructor.
@param aMachine A reference to the parent state machine.
*/  
CSuplMtLrStateHandler::CSuplMtLrStateHandler(CSuplFsmSessionBase& aMachine)
: CSuplStateHandlerBase(aMachine)
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::CSuplMtLrStateHandler() Begin\n");
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::CSuplMtLrStateHandler() End\n");
	}


/** Standard destructor.
*/  
CSuplMtLrStateHandler::~CSuplMtLrStateHandler()
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::~CSuplMtLrStateHandler() Begin\n");
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::~CSuplMtLrStateHandler() End\n");
	}

	
/** Perform entry actions.
This is called from the state machine to perform any actions
associated with entering the current state following an external
event or an autonomous state transition.

For some states, there is only one possible course of action.
For other states, the event store has to be checked to see what
events have occurred and what actions have to be taken to handle
such events.

If an event conductive to cancelling the state machine had occurred
(e.g, an explicit client cancel, an error, or a timeout), then the
state machine would have been set in an state that terminates the 
session before this method is called (either EStateSuplSessionEnded
or EStatePosSessionEnded).

@return TBool ETrue if any actions have been taken
*/  
TBool CSuplMtLrStateHandler::EntryActionsL()
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsL() Begin\n");
	TBool actionsTaken = ETrue;
	// Retrieve current state and act accordingly
	switch(iMachine.CurrentState())
		{
		case CSuplFsmSessionBase::EStateProcedureNull:
			// No action required
			break;
		
		case CSuplFsmSessionBase::EStateSuplInitReceived:
			actionsTaken = EntryActionsFromSuplInitReceived();
			break;
			
		case CSuplFsmSessionBase::EStateNetConnectionStarted:
			actionsTaken = EntryActionsFromNetConnectionStarted();
			break;
			
		case CSuplFsmSessionBase::EStatePosInitSent:
			// Build and send a SUPL POS INIT
			actionsTaken = EntryActionsFromPosInitSentStateL();
			break;

		case CSuplFsmSessionBase::EStatePositioningInProgress:
			actionsTaken = EntryActionsFromPositioningInProgressStateL();
			break;

		case CSuplFsmSessionBase::EStatePositionReceived:
			actionsTaken = EntryActionsFromPositionReceivedStateL();
			break;
			
		case CSuplFsmSessionBase::EStateSuplSessionEnded:
			// Send SUPL END
			actionsTaken = EntryActionsFromSuplSessionEndedStateL();
			break;

		case CSuplFsmSessionBase::EStatePosSessionEnded:
			// Send to Positioning FSM an instruction to terminate silently
			//
			iMachine.PositioningFsm()->CancelMachine(CSuplPositioningProtocolFsm::ESuplFsmCancel, CSuplFsmSessionBase::EReasonNone);
			break;
			
		case CSuplFsmSessionBase::EStateLbsSessionEnded:
			// Send session complete indication to LBS
			actionsTaken = EntryActionsFromLbsSessionEndedStateL();
			break;
			
		case CSuplFsmSessionBase::EStateNetConnectionClosed:
			// Close the network connection
			iMachine.CompleteProcedure();
			break;

		default:
			ASSERT(EFalse);
			break;
		}
	
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsL() End\n");
	return actionsTaken;
	}
//---------------------------------------------------------------------------------------------------------------------
// -----------------------     METHODS FOR ACTIONS AFTER ENTERING STATES  ---------------------------------------------
//---------------------------------------------------------------------------------------------------------------------

/** Actions on entering state EStateSuplInitReceived
This method sends a LocationRequest and a PrivacyRequest
to LBS.
*/
TBool CSuplMtLrStateHandler::EntryActionsFromSuplInitReceived()
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromSuplInitReceived() Begin\n");
	TLbsNetPosRequestPrivacy privacyAdvice;
	TLbsExternalRequestInfo requestor;
	TLbsNetPosRequestMethod posMethods;
	TLbsNetPosMethod selectedMethod; // only one method is sent to LBS
	TLbsNetPosRequestQuality quality;

	// Send a PrivacyRequest followed by a Location Request to LBS
	iMachine.RetrievePrivacyAdvice(privacyAdvice);
	iMachine.RetrieveRequestorInfo(requestor);
	iMachine.Observer().PrivacyReq(iMachine.LbsSessionId(), privacyAdvice, requestor);


	// Get the pos methods received in a SUPL INIT
	// (kept in event store).
	iMachine.RetrieveInitPosMethod(posMethods);
	TLbsNetPosMethod netPrefMethod;
	posMethods.GetPosMethod(0, netPrefMethod);
	if (KLbsPositioningMeansNone != netPrefMethod.PosMeans()) // not a "noPosition" INIT
		{
		// Check that there are supported positioning methods different 
		// from Cell Based (Cell-Based can't be requested from LBS).
		TLbsNetPosCapabilities capabilities;
		iMachine.Observer().Gateway().GetCapabilities(capabilities);
		if (iMachine.PosMethodSupported(posMethods, selectedMethod,capabilities) &&
			KLbsPositioningMeansCell != selectedMethod.PosMeans())
			{
			// Method to be presented to LBS
			posMethods.SetPosMethods(&selectedMethod, 1);
			}
		else
			{
			// No mutually supported positioning methods.
			// Send to LBS the positioning method that is preferred
			// by LBS (the first in the capabilities)
			capabilities.GetPosMethod(0, selectedMethod);
			posMethods.SetPosMethods(&selectedMethod, 1);
			}

		iMachine.RetrieveInitQuality(quality);
		iMachine.Observer().LocationReq(iMachine.LbsSessionId(),	iMachine.LocReqType(),
										   quality, posMethods);	
		}

	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromSuplInitReceived() End\n");
	return ETrue;
	}
	

/** Actions on entering state EStateNetConnectionStarted

This method obtains an SLP Id from the Host Settings store
and asks the Connection Manager to provide a connection with it.
*/
TBool CSuplMtLrStateHandler::EntryActionsFromNetConnectionStarted()
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromNetConnectionStarted() Begin\n");
	TBool ret = ETrue;
	TLbsHostSettingsId hostId = TUid::Uid(0);
	TLbsNetSessionId::TSessionNum sessIdNum = 0;
	// Request a connection if one has not been set up already
	if (!iMachine.IsSessionConnected())
		{
		TInt err = iMachine.GetHostId(hostId); 
			
		if (KErrNone == err)
			{
			// Request a connection from the Connection Manager
			//
			sessIdNum = iMachine.SessionId().SessionNum();
			iMachine.Observer().ConnectionManager().Connect(sessIdNum, hostId, CSuplSessionRecord::EServiceMtlr, iMachine);
			// start the timer that oversees connection creation
			iMachine.StartConnectionTimer();		
			}
		else
			{
			// Cancel session as a SUPL server could not be determined
			iMachine.CancelMachine(CSuplFsmSessionBase::ECancelSuplProt, CSuplFsmSessionBase::EReasonSlpSettingsMissing);
			}
		}
	else
		{
		 // This will happen if the connection has been created but the state
		 // machine remains in EStateNetConnectionStarted due to being waiting
		 // for an event from LBS (either a position notification or an assistance
		 // data request). Nothing to be done.
		 ret = EFalse;
		}
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromNetConnectionStarted() End\n");
	return ret;
	}
	


/** Actions on entering state EStatePosInitSent
This method builds a SUPL POS INIT message and hands it over to 
the Connection Manager for sending to the SUPL server.
*/
TBool CSuplMtLrStateHandler::EntryActionsFromPosInitSentStateL()
	{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromPosInitSentStateL() Begin\n");
	TBool err = EFalse;
	TLbsNetPosRequestQuality quality;
	TLbsNetPosCapabilities capabilities;
	TBool actionsTaken = EFalse;
	
	// There should be either an assistance data request 
	// or a position from LBS in the event store
	if (iMachine.IsAssistanceDataRequestStored() || iMachine.IsPositionStored())
		{
		ASSERT(iMachine.IsSessionConnected()); // should not have transitioned into this state without a connection

		// Create the SUPL POS INIT Message
		CSuplPosInit* suplPosInit = CSuplPosInit::NewL();
		CleanupStack::PushL(suplPosInit);
		
		// Set the Location Id in the message
		CSuplLocationId* locationId;
		if (BuildLocationIdL(locationId))
			{
			CleanupStack::PushL(locationId);

			suplPosInit->SetLocationId(*locationId);
			CleanupStack::PopAndDestroy(locationId);

			// Set Capabilities in the message
			BuildCapabilitiesL(capabilities,quality);
		    User::LeaveIfError(suplPosInit->SetCapabilities(capabilities));

		    // Set either a supplied position or assistance data request in the message
		 	if (iMachine.IsPositionStored())
			 	{
				TPositionInfoBase* posPtr = iMachine.RetrievePositionL();
				User::LeaveIfError(suplPosInit->SetPosition(*posPtr));
			 	}
			else if (iMachine.IsAssistanceDataRequestStored())
				{
				TLbsAsistanceDataGroup assitDataReqMask;
				TBool assitDataReqPresent = iMachine.RetrieveAssistanceDataRequest(assitDataReqMask);
				if (assitDataReqMask != 0)
					{
					User::LeaveIfError(suplPosInit->SetRequestedAssistanceData(assitDataReqMask));
					}
				else
					{
					// This was an empty assistance data request. No need to set it
					// in the POS INIT message (intentionally no action take here)
					}
				}
			
			// Set in message header the stored session id
			// after adding to it the SET session ID
			CSuplSessionId* sessionId = iMachine.MessageSessionId();
			TUint32 ipAddr = iMachine.RetrieveLocalIpAddress().Address();
			sessionId->iSetSessionIdPresent = ETrue;
			sessionId->iSetSessionId->iSessionId = iMachine.SessionId().SessionNum();
			sessionId->iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeMsisdn; // TSuplSetIdType
			
			const TUint8 KMaxMsisdnLength = 8;
			TDes8& des = sessionId->iSetSessionId->iSetId->iSetId;
			if(iMachine.Msisdn())
				{
				ConvertToBcd(des);
				}
			else
				{
				//Fill the descriptor with all bits set to 0, then append a 0xFF to the end to indicate the end of the MSISDN
				des.SetLength(KMaxMsisdnLength);
				des.Fill(0x00, (KMaxMsisdnLength -1));	//7 0's
				des.Append(0xFF);	//Final 1 FF
				}
			
			//sessionId->iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeIPAddress;
			//sessionId->iSetSessionId->iSetId->iIpAddress->iIpAddressType = ESuplIpAddressTypeV4;
			//sessionId->iSetSessionId->iSetId->iIpAddress->iIpAddress.Copy(reinterpret_cast<unsigned char*>(&ipAddr), 4);
			
			User::LeaveIfError(suplPosInit->SetSessionId(*sessionId));
			
			// Set in message the Ver field
			TBuf8<8> ver;
			iMachine.RetrieveVer(ver);
			User::LeaveIfError(suplPosInit->SetVer(ver));
			
			CleanupStack::Pop(suplPosInit);
			// Ask the Connection Manager to send the SUPL POS INIT message
			iMachine.Observer().ConnectionManager().SendMessage(suplPosInit, iMachine.SessionId().SessionNum());

			// Start the timer that oversees the arrival of SUPL POS
			iMachine.StartSuplPosTimer();
			
			actionsTaken = ETrue;
			}
		else
			{
			// Failed to build Location Id
			err = ETrue;
			CleanupStack::PopAndDestroy(suplPosInit);
			}
		}
	else
		{
		err = ETrue;
		}
		
	if (err)
		{
		iMachine.CancelMachine(CSuplFsmSessionBase::ECancelSuplProt, CSuplFsmSessionBase::EReasonNone);			
		}
	
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::EntryActionsFromPosInitSentStateL() End\n");
	return actionsTaken;
	}

/**
Utility method that builds the capabilities to send in a SUPL POS INIT using LBS's supported
capabilities and network preferred positioning method.
*/
TBool CSuplMtLrStateHandler::BuildCapabilitiesL(TLbsNetPosCapabilities& aCapabilities, TLbsNetPosRequestQuality& aQuality)
{
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::BuildCapabilitiesL() Begin\n");
	TLbsNetPosRequestMethod locReqMethods;
	TLbsNetPosMethod prefMethod;
	TInt numMethods;
	TInt index;
	TBool ecidSupported = EFalse;
	TInt additionalMethods = 1; // preferred method

	iMachine.Observer().Gateway().GetCapabilities(aCapabilities);
	numMethods = aCapabilities.NumPosMethods();
	// Check if E-CID is possible
	// (currently this mean Timing Advance only)
	if(iMachine.IsNetworkInfoAvailable())
		{
		RMobilePhone::TMobilePhoneNetworkInfoV1 networkInfo;
		RMobilePhone::TMobilePhoneLocationAreaV1 locationArea;
		iMachine.RetrieveStoredNetworkInfo(networkInfo, locationArea);	
		if (RMobilePhone::ENetworkModeGsm == networkInfo.iMode)
			{
			RMobilePhone::TMobilePhoneCellInfoV9 cellInfo;
			if(iMachine.RetrieveStoredCellInfo(cellInfo))
				{
				// Timing Advance not supported if negative
				ecidSupported = (cellInfo.iTimingAdvance >= 0);
				additionalMethods++;
				}
			}
		}

	// Determine what method has been used for this session (prefMethod).
	// The positioning method preferred by the SLP had been received in the 
	// SUPL INIT message and is kept in the event store.
	iMachine.RetrieveInitPosMethod(locReqMethods);
	TLbsNetPosCapabilities capabilities;
	iMachine.Observer().Gateway().GetCapabilities(capabilities);
	if (!iMachine.PosMethodSupported(locReqMethods, prefMethod, capabilities) &&
			KLbsPositioningMeansCell != prefMethod.PosMeans())
		{
		// No pos method received from the SLP was used for the session as
		// no supported method was found. The first method in 
		// the array of capabilities (LBS's preferred) was used instead. Get it.
		aCapabilities.GetPosMethod(0, prefMethod);
		}

	// The prefMethod has to be added at the end of the array of methods in aCapabilities
	// because that is where the ASN1 encoder expects it to be.
	// If E-CID is supported and there is room for it in the array, it will also be added to the 
	// array.
	TLbsNetPosMethod* methods = NULL;
	if  (numMethods + additionalMethods < KLbsMaxNetPosMethods)
		{
		TLbsNetPosMethod ecidMethod;
		ecidMethod.SetPosMethod(KLbsPositioningMeansCell, TPositionModuleInfo::ETechnologyNetwork);
		methods = new (ELeave) TLbsNetPosMethod[numMethods + additionalMethods];
		
		for (index =0; index < numMethods; index++)
			{
			aCapabilities.GetPosMethod(index, methods[index]);
			}
			
		if (ecidSupported)
			{
			methods[numMethods] = ecidMethod;	
			}
			
		// Add preferred method at the end
		methods[numMethods + additionalMethods - 1] = prefMethod;
		aCapabilities.SetPosMethods(methods, numMethods + additionalMethods);
		}
	else 
		{
		// There is only additional room for 1 or 0 methods.
		methods = new (ELeave) TLbsNetPosMethod[KLbsMaxNetPosMethods];
		for (index =0; index < KLbsMaxNetPosMethods; index++)
			{
			aCapabilities.GetPosMethod(index, methods[index]);
			}

		// Set the preferred method at the end (even if it 
		// overwrites current entry)
		methods[KLbsMaxNetPosMethods-1] = prefMethod;
		aCapabilities.SetPosMethods(methods, KLbsMaxNetPosMethods);	
		}
			
	delete[] methods;

	iMachine.RetrieveInitQuality(aQuality);
	SUPLLOG(ELogP1, "CSuplMtLrStateHandler::BuildCapabilitiesL() End\n");
	return ETrue;
}