1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <e32std.h>

    17 #include <e32property.h>

    18 

    19 // LBS-specific

    20 #include <lbs.h>

    21 #include <lbs/lbsadmin.h>

    22 #include <lbs/lbslocerrors.h>

    23 #include <lbs/lbslocclasstypes.h>

    24 

    25 #include "nrhpanic.h"

    26 #include "lbsdevloggermacros.h"

    27 #include "lbsqualityprofile.h"

    28 

    29 #include "privacyandlocationrequesthandler.h"

    30 

    31 // Special 'invalid session' SessionId.

    32 const TLbsNetSessionIdInt KInvalidSessionId(TUid::Uid(0), 0);

    33 

    34 const TPositionModuleInfo::TTechnologyType KTerminalAssistedMode = (TPositionModuleInfo::ETechnologyNetwork |

    35 																	TPositionModuleInfo::ETechnologyAssisted);

    36 	

    37 // ----------------------------------------------------------------------------- 

    38 // 

    39 // ----------------------- Class CPrivacyAndLocationHandler --------------------

    40 //

    41 // State Machine class which owns the states of the Privacy and Location Handler

    42 //

    43 // ----------------------------------------------------------------------------- 

    44 //

    45 

    46 // ----------------------------------------------------------------------------- 

    47 // CPrivacyAndLocationHandler::NewL

    48 // Description: CPrivacyAndLocationHandler static constructor 

    49 // ----------------------------------------------------------------------------- 

    50 //

    51 CPrivacyAndLocationHandler* CPrivacyAndLocationHandler::NewL(CNGMessageSwitch& aMessageSwitch,

    52 											CLbsAdmin& aLbsAdmin,

    53 											RLbsNetworkRegistrationStatus& aNetRegStatus)

    54 	{

    55 	CPrivacyAndLocationHandler* self; 

    56 	self = new (ELeave) CPrivacyAndLocationHandler(aMessageSwitch, aNetRegStatus);

    57 	CleanupStack::PushL(self);

    58 	self->ConstructL(&aLbsAdmin);

    59 	CleanupStack::Pop(self);

    60 	return(self);	

    61 	}

    62 

    63 // ----------------------------------------------------------------------------- 

    64 // CPrivacyAndLocationHandler::CPrivacyAndLocationHandler

    65 // Description: CPrivacyAndLocationHandler constructor 

    66 // ----------------------------------------------------------------------------- 

    67 //

    68 CPrivacyAndLocationHandler::CPrivacyAndLocationHandler(CNGMessageSwitch& aMessageSwitch, 

    69 													   RLbsNetworkRegistrationStatus& aNetRegStatus)

    70 :	iNetRegStatus(aNetRegStatus),

    71 	iMessageSwitch(&aMessageSwitch),

    72 	iNumActiveSessions(0)

    73 	{	

    74 	}

    75 	

    76 // ----------------------------------------------------------------------------- 

    77 // CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler

    78 // Description: CPrivacyAndLocationHandler destructor 

    79 // ----------------------------------------------------------------------------- 

    80 //

    81 CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler()

    82 	{

    83 	// If iEmergencyFsm has been used by any outstanding request,

    84 	// it needs to be removed before calling ResetAndDestroy(),

    85 	// otherwise it will get double-deleted when delete iEmergencyFsm

    86 	// is called.

    87 			

    88 	TInt index = iFsmArray.Find(iEmergencyFsm);

    89 	if (index >= 0)

    90 		{

    91 		iFsmArray.Remove(index);

    92 		}

    93 	

    94 	iFsmArray.ResetAndDestroy();

    95 

    96 

    97 	delete iEmergencyFsm;

    98     delete iAgpsInterface;

    99     delete iPrivacyHandler;

   100 	}

   101 

   102 // ----------------------------------------------------------------------------- 

   103 // CPrivacyAndLocationHandler::ConstructL

   104 // Description: CPrivacyAndLocationHandler second-phase constructor.

   105 //              Creates the states of the system and the Privacy Handler.

   106 // ----------------------------------------------------------------------------- 

   107 //

   108 

   109 const TInt KLbsDefaultMaxNumLocationRequests   = 4;

   110 

   111 void CPrivacyAndLocationHandler::ConstructL(CLbsAdmin* aLbsAdmin)

   112 	{

   113 	iLbsAdmin = aLbsAdmin;

   114 	

   115 	iPrivacyHandler = CPrivacyHandler::CreateL(this, *iLbsAdmin, iNetRegStatus);

   116 	iMessageSwitch->RegisterObserver(this);

   117 

   118 	// Get the behaviour mode and device gps mode capabilities

   119 	TInt err = iLbsAdmin->Get(KLbsSettingBehaviourMode, iLbsBehaviourMode);

   120 	if (err != KErrNone)

   121 		{

   122 		iLbsBehaviourMode = CLbsAdmin::ELbsBehaviourCustom1;

   123 		}

   124 	// get device mode capabilities:

   125 	err = LbsModuleInfo::GetDeviceCapabilities(KLbsGpsLocManagerUid, iDeviceGpsModeCaps);

   126 	if(err != KErrNone || (iDeviceGpsModeCaps==TPositionModuleInfoExtended::EDeviceGpsModeNone))

   127 		{

   128 		// Assume module supports hybrid if it has not reported its capabilities in module info file

   129 		iDeviceGpsModeCaps = TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB;

   130 		}

   131 

   132 

   133 	err = iLbsAdmin->Get(KLbsSettingMaximumExternalLocateRequests, iMaxNumSessions);

   134 	if (err != KErrNone)

   135 		{

   136 		iMaxNumSessions = KLbsDefaultMaxNumLocationRequests;

   137 		}

   138 	

   139 	iAgpsInterface = CAgpsInterfaceHandler::NewL(*this, *iLbsAdmin, iNetRegStatus);

   140 

   141 

   142 #ifdef NRH_UNIT_TEST

   143 	// For testing use the Uid of the dummy NG

   144 	const TInt KTestNgUidInt = 0x1028226B;

   145 	const TUid KTestNgUid = {KTestNgUidInt};

   146 	iProtocolModuleUid = KTestNgUid;

   147 #else

   148 	ReadProtocolModuleAdminSetting();

   149 #endif

   150 	

   151 	iEmergencyFsm = CLbsPrivLocFsm::NewL(*this, KInvalidSessionId);

   152 	

   153 	// Reserve space for FSMs. Note "+1" because a pointer to the emergency Fsm gets added to this array

   154 	iFsmArray.ReserveL(iMaxNumSessions+1);

   155 

   156 	CLbsAdmin::TSpecialFeature specialFeature(CLbsAdmin::ESpecialFeatureOff);

   157 	err = iLbsAdmin->Get(KLbsSpecialFeatureIntermediateFutileUpdate, specialFeature);

   158 	if (err != KErrNone)

   159 		{

   160 		LBSLOG_ERR2(ELogP3, "Failed to get KLbsSpecialFeatureIntermediateFutileUpdate (err %d)", err);

   161 		}

   162 	LBSLOG2(ELogP3, "Using KLbsSpecialFeatureIntermediateFutileUpdate = %d", specialFeature);

   163 	iSpecialFeatureIntermediateFutileUpdate = (specialFeature == CLbsAdmin::ESpecialFeatureOn) ? ETrue : EFalse;

   164 	}

   165 

   166 

   167 

   168 /**

   169 Reads the Uid of a current Protocol Module from the Admin Settings.

   170 */

   171 void CPrivacyAndLocationHandler::ReadProtocolModuleAdminSetting()

   172 	{

   173 	LBSLOG(ELogP1, "CPrivacyAndLocationHandler::ReadProtocolModuleAdminSetting()");

   174 	TLbsProtocolModuleId protUid(KLbsProtocolNullModuleId);

   175 	

   176 	TInt err = iLbsAdmin->Get(KLbsSettingHomeProtocolModule, protUid);

   177 	if (err != KErrNone)

   178 		{

   179 		LBSLOG_ERR2(ELogP4, "Failed to get KLbsSettingHomeProtocolModule (err %d)", err);

   180 		}

   181 

   182 	iProtocolModuleUid = protUid;

   183 	}

   184 

   185 /** Compares sessionId for RPointerArray::Find().

   186 */

   187 TBool CPrivacyAndLocationHandler::IsSessionIdEqual(

   188 		const TLbsNetSessionIdInt* aSessionId,

   189 		const CLbsPrivLocFsm& aFsm)

   190 	{

   191 	return (*aSessionId == aFsm.SessionId());

   192 	}

   193 

   194 /** Compares session type for RPointerArray::Find().

   195 */

   196 TBool CPrivacyAndLocationHandler::IsSessionTypeEqual(

   197 		const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt* aSessionType,

   198 		const CLbsPrivLocFsm& aFsm)

   199 	{

   200 	return (*aSessionType == const_cast<CLbsPrivLocFsm&>(aFsm).SessionType());

   201 	}

   202 

   203 // ----------------------------------------------------------------------------- 

   204 // CPrivacyAndLocationHandler::LookupFsm

   205 // Description: Lookup CLbsPrivLocFsm object by session ID.

   206 // ----------------------------------------------------------------------------- 

   207 //

   208 CLbsPrivLocFsm* CPrivacyAndLocationHandler::LookupFsm(const TLbsNetSessionIdInt& aSessionId)

   209 	{

   210 	LBSLOG2(ELogP3, "LookupFsm session=%d", aSessionId.SessionNum());

   211 

   212 	// Standard sessions always use the standard state machines.

   213 	TInt index = iFsmArray.Find(aSessionId, IsSessionIdEqual);

   214 	if (index >= 0)

   215 		{

   216 		LBSLOG(ELogP3, "LookupFsm: Existing standard FSM found");

   217 		return iFsmArray[index];

   218 		}

   219 	else

   220 		{

   221 		LBSLOG(ELogP3, "LookupFsm: No standard FSM found");

   222 		return NULL;		

   223 		}

   224 	}

   225 

   226 /** Get a new state machine to use for a new request.

   227 

   228 The state machine can either be re-using an existing FSM,

   229 or allocating a new one from the heap or, for emergencies one thats was prepared earlier is used.

   230 */

   231 CLbsPrivLocFsm* CPrivacyAndLocationHandler::GetNewFsm(

   232 		const TLbsNetSessionIdInt& aSessionId,

   233 		TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType,

   234 		TBool aEmergency)

   235 	{

   236 	LBSLOG2(ELogP3, "LookupFsm session=%d", aSessionId.SessionNum());

   237 	

   238 	CLbsPrivLocFsm* fsm(NULL);

   239 

   240 	// If this is an emergency request, use the emergency FSM  

   241 	// Note, we only have to support ONE emergency at a time

   242 	// this implies that only one Protcol module may deal with emergencies

   243 	// So we do NOT support TWO emergencies .. one from each of the PMs

   244 	// Note: only MT-LR or NI-LR requests can be emergency requests.

   245 	if (aEmergency

   246 		&& (aSessionType == MLbsNetworkProtocolObserver::EServiceMobileTerminated

   247 		|| aSessionType == MLbsNetworkProtocolObserver::EServiceNetworkInduced))

   248 		{					

   249 		TInt index = iFsmArray.Find(iEmergencyFsm);

   250 		if (index >= 0)

   251 			{

   252 			iFsmArray.Remove(index);

   253 			iNumActiveSessions--;

   254 			}

   255 		// clean out Fsm

   256 		iEmergencyFsm->RefPosProcessed() = EFalse;

   257 		iEmergencyFsm->LocReqReceived() = EFalse;

   258 		iEmergencyFsm->LocationFixReceived()= EFalse;

   259 		iEmergencyFsm->TapMode() = EFalse;

   260 		iEmergencyFsm->WasPrivacyResponseReceivedStateExited() = EFalse;

   261 		iEmergencyFsm->NetSessionId()= aSessionId;

   262 		fsm = iEmergencyFsm;

   263 		}

   264 	else

   265 		{

   266 		if (iNumActiveSessions <= iMaxNumSessions)

   267 			{

   268 			// Create a new session to handle this privacy request

   269 			LBSLOG2(ELogP3, "Creating FSM for new standard request %d",aSessionId.SessionNum());

   270 			TRAPD(err, fsm = CLbsPrivLocFsm::NewL(*this, aSessionId)); 

   271 			if (err != KErrNone)

   272 				{

   273 				LBSLOG_ERR2(ELogP3, "Failed to create new FSM, error code : %d", err);

   274 				}

   275 			}

   276 		else

   277 			{

   278 			LBSLOG_ERR3(ELogP3, "Session start rejected! iNumActiveSessions=%d > iMaxNumSessions=%d", iNumActiveSessions, iMaxNumSessions);

   279 			}

   280 		}

   281 

   282 	if (fsm)

   283 		{

   284 		// Add the state machine to the buffer.

   285 		iFsmArray.Append(fsm);

   286 	

   287 		iNumActiveSessions++; // conceptually, a session starts when a Fsm is created for it

   288 

   289 		}

   290 	

   291 	return fsm;

   292 	}

   293 

   294 

   295 // ----------------------------------------------------------------------------- 

   296 // CPrivacyAndLocationHandler::PrivacyHandler

   297 // Description: Return a pointer to the privacy handler implementation

   298 //              (controller or notifier).

   299 // ----------------------------------------------------------------------------- 

   300 //

   301 CPrivacyHandler* CPrivacyAndLocationHandler::PrivacyHandler()

   302 	{

   303 	return iPrivacyHandler;

   304 	}

   305 	

   306 // ----------------------------------------------------------------------------- 

   307 // CPrivacyAndLocationHandler::MessageSwitch

   308 // Description: Return a pointer to the Network Gateway Message Switch

   309 // ----------------------------------------------------------------------------- 

   310 //

   311 CNGMessageSwitch* CPrivacyAndLocationHandler::MessageSwitch()

   312 	{

   313 	return iMessageSwitch;

   314 	}

   315 	

   316 // ----------------------------------------------------------------------------- 

   317 // CPrivacyAndLocationHandler::LbsAdmin

   318 // Description: Return a pointer to the Admin settings database

   319 // ----------------------------------------------------------------------------- 

   320 //

   321 CLbsAdmin* CPrivacyAndLocationHandler::LbsAdmin()

   322 	{

   323 	return iLbsAdmin;

   324 	}

   325 	

   326 // ----------------------------------------------------------------------------- 

   327 // CPrivacyAndLocationHandler::SetServerObserver

   328 // Description: Store a pointer to the NRH server which comunicates with the 

   329 // Privacy Controller.

   330 // ----------------------------------------------------------------------------- 

   331 //

   332 void CPrivacyAndLocationHandler::SetServerObserver(MLbsSessionObserver* aNrhServer)

   333     {

   334     PrivacyHandler()->SetServerObserver(aNrhServer);

   335     }

   336 

   337 // ----------------------------------------------------------------------------- 

   338 // CPrivacyAndLocationHandler::OnRespondNetworkLocationRequest

   339 // Description: Called by the Privacy Handler to report the result of a privacy

   340 // check. Handling of the response is delegated to the current state.

   341 // ----------------------------------------------------------------------------- 

   342 //

   343 void CPrivacyAndLocationHandler::OnRespondNetworkLocationRequest(const TLbsNetSessionIdInt& aRequestId, 

   344                             TLbsNetworkEnumInt::TLbsPrivacyResponseInt aRequestResult,

   345                             TInt aResponseReason)

   346 	{

   347 	LBSLOG2(ELogP3, "Received response %d to privacy request", aRequestResult);

   348 	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

   349 	

   350 	if (NULL != fsm)

   351 		{

   352 		fsm->OnRespondNetworkLocationRequest(aRequestId, aRequestResult, aResponseReason);

   353 		}

   354 	else

   355 		{

   356 		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   357 		}

   358     }

   359 

   360 // ----------------------------------------------------------------------------- 

   361 // CPrivacyAndLocationHandler::OnCancelNetworkLocationRequest

   362 // Description: Called by the Privacy Handler to report that a privacy check 

   363 // has been rejected. This may occur after it has already been accepted.

   364 // Handling of the response is delegated to the current state.

   365 // ----------------------------------------------------------------------------- 

   366 //

   367 void CPrivacyAndLocationHandler::OnCancelNetworkLocationRequest(const TLbsNetSessionIdInt& aRequestId)

   368     {

   369 	LBSLOG2(ELogP3, "Received cancellation to privacy request %d", aRequestId.SessionNum());

   370 	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

   371 	

   372 	if (NULL != fsm)

   373 		{

   374 		fsm->OnCancelNetworkLocationRequest(aRequestId);

   375 		}

   376 	else

   377 		{

   378 		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   379 		}

   380     }

   381 

   382 // ----------------------------------------------------------------------------- 

   383 // CPrivacyAndLocationHandler::OnMTLRRequest

   384 // Description: The Message Switch has forwarded a request to start an MTLR 

   385 // session.

   386 // Handling of the request is delegated to the current state.

   387 // ----------------------------------------------------------------------------- 

   388 //

   389 void CPrivacyAndLocationHandler::OnMTLRRequest(const TLbsNetSessionIdInt& aSessionId,

   390 					   TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   391 					   TBool aIsEmergency,

   392 					   const TLbsExternalRequestInfo& aExternalRequestInfo,

   393 					   const TLbsNetPosRequestPrivacyInt& aNetPosRequestPrivacy)

   394 	{

   395 	LBSLOG2(ELogP3, "Received privacy request with id %d", aSessionId.SessionNum());

   396 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   397 

   398 	if (fsm==NULL)

   399 		{

   400 		fsm = GetNewFsm(aSessionId, aSessionType, aIsEmergency);

   401 		}

   402 	

   403 	if (NULL != fsm)

   404 		{

   405 		fsm->OnMTLRRequest(aSessionId, 

   406 						   aSessionType, 

   407 						   aIsEmergency, 

   408 						   aExternalRequestInfo, 

   409 						   aNetPosRequestPrivacy);

   410 		}

   411 	else

   412 		{					

   413 		// Failed to create a state machine for this request,

   414 		// so simply reply with a privacy rejection.

   415 		iMessageSwitch->SendMTLRResponse(aSessionId, 

   416 										 TLbsNetworkEnumInt::EPrivacyResponseRejected,

   417 										 KErrGeneral, EFalse); // can't be an emergency cuase we know we have a Fsm for these!

   418 		}

   419 	}

   420 	

   421 // ----------------------------------------------------------------------------- 

   422 // CPrivacyAndLocationHandler::OnSessionComplete

   423 // Description: The Message Switch has reported that the session is

   424 // over (complete or aborted due to some error).

   425 // Handling of the message is delegated to the current state.

   426 // ----------------------------------------------------------------------------- 

   427 //

   428 void CPrivacyAndLocationHandler::OnSessionComplete(

   429 									const TLbsNetSessionIdInt& aSessionId,

   430 									TInt aReason)

   431 	{

   432 	LBSLOG3(ELogP3, "Received Session Complete for id %d, reason %d", aSessionId.SessionNum(), aReason);

   433 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   434 	

   435 	if (NULL != fsm)

   436 		{

   437 		fsm->OnSessionComplete(aSessionId, aReason);

   438 

   439 		// The session complete marks the end of a session.

   440 		TInt index = iFsmArray.Find(fsm);

   441 		if (index != KErrNotFound)

   442 			{ 

   443 			

   444 			if (fsm->SessionType()== TLbsNetworkEnumInt::EServiceSelfLocation)

   445 				{

   446 				iMolRFsm = NULL;

   447 				}

   448 			else if (fsm->SessionType()== TLbsNetworkEnumInt::EServiceTransmitThirdParty)

   449 				{

   450 				iX3pFsm = NULL;

   451 				}

   452 			

   453 			// We should never delete the emergency FSM.

   454 			iFsmArray.Remove(index);

   455 			iNumActiveSessions--;

   456 			

   457 			if (fsm != iEmergencyFsm)

   458 				{

   459 				delete fsm;

   460 				}

   461 			}

   462 		}

   463 	else

   464 		{

   465 		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   466 		}

   467 	}

   468 

   469 // ----------------------------------------------------------------------------- 

   470 // CPrivacyAndLocationHandler::OnNetLocRequest

   471 // Description: The Message Switch has passed on a request for a position update

   472 // Handling of the request is delegated to the current state.

   473 // ----------------------------------------------------------------------------- 

   474 //

   475 void CPrivacyAndLocationHandler::OnNetLocRequest(

   476 						const TLbsNetSessionIdInt& aSessionId, 

   477 						const TLbsNetPosRequestMethodInt& aPosRequestMethod,

   478 						TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   479 						TBool aIsEmergency,

   480 						const TLbsNetPosRequestQualityInt& aQuality)

   481 	{

   482 	LBSLOG2(ELogP3, "Received position update request for id %d", aSessionId.SessionNum());

   483 	

   484 	TLbsNetSessionIdInt sessionId;

   485 	TPositionInfo    posInfo;

   486 	TPosition		 pos;

   487 	TTime 			 timeStamp;

   488 	TInt 			 err;

   489 	

   490 	TBool tapMode = EFalse;

   491 	TInt numMethods = aPosRequestMethod.NumPosMethods();

   492     if (numMethods==1)

   493     	{

   494     	TLbsNetPosMethodInt netPosMethod;

   495     	aPosRequestMethod.GetPosMethod(0,netPosMethod);

   496                  

   497     	if (netPosMethod.PosMode()== (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted))

   498     		{

   499     		tapMode = ETrue;

   500     		}

   501     	}

   502 	

   503 	// This filtering used to be in the NG Message Switch, but has been moved

   504 	// here to get an access to the ref position bus

   505 	

   506 	if( (aSessionType == TLbsNetworkEnumInt::EServiceNetworkLocation) && !tapMode)

   507 		{

   508 		// A Network-based location request generates a location 

   509 		// request to the network request handler, but there's no point 

   510 		// passing it any further - the AGPS manager & privacy 

   511 		// controller aren't interested.

   512 		// Simply return the saved reference location

   513 		err = iMessageSwitch->GetNetworkReferencePosition(aSessionId, posInfo);			

   514 		posInfo.GetPosition(pos);

   515 		timeStamp = pos.Time();

   516 		TLbsNetPosRequestQualityInt dummyQuality;

   517 		MessageSwitch()->SendNetLocResponse(aSessionId, err, dummyQuality, posInfo, timeStamp, EFalse);

   518 		}

   519 	else

   520 		{

   521 		// we note that a self locate MoLr session can be implicitly

   522 		// cancelled by the start of a new session for a new client.

   523 		// In this case we complete the session before creating a new

   524 		// fsm for the new client 

   525 		CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   526 		if (!fsm)

   527 			{

   528 			// here, we need to create a new fsm

   529 			// We note that only one self locate MolR (or X3p) is supported

   530 			// a new one will implicitly cancel any ongoing

   531 			if(aSessionType == TLbsNetworkEnumInt::EServiceSelfLocation)

   532 				{

   533 				if (iMolRFsm)

   534 					{

   535 					TInt index = iFsmArray.Find(iMolRFsm);

   536 					if (index != KErrNotFound)

   537 						{ 

   538 						iFsmArray.Remove(index);

   539 						iNumActiveSessions--;

   540 						delete iMolRFsm;

   541 						iMolRFsm = NULL;

   542 						}

   543 					}

   544 					

   545 				}

   546 			else if(aSessionType == TLbsNetworkEnumInt::EServiceTransmitThirdParty)

   547 				{

   548 				if (iX3pFsm)

   549 					{

   550 					TInt index = iFsmArray.Find(iX3pFsm);

   551 					if (index != KErrNotFound)

   552 						{ 

   553 						iFsmArray.Remove(index);

   554 						iNumActiveSessions--;

   555 						delete iX3pFsm;

   556 						iX3pFsm = NULL;

   557 						}

   558 					}

   559 				}

   560 				

   561 			fsm = GetNewFsm(aSessionId, aSessionType, aIsEmergency);

   562 			}

   563 		

   564 		if (NULL != fsm)

   565 			{

   566 			if(aSessionType == TLbsNetworkEnumInt::EServiceSelfLocation)

   567 				{

   568 				iMolRFsm = fsm;

   569 				}

   570 			else if(aSessionType == TLbsNetworkEnumInt::EServiceTransmitThirdParty)

   571 				{

   572 				iX3pFsm = fsm;

   573 				}

   574 			

   575 			fsm->OnNetLocRequest(aSessionId,

   576 					aPosRequestMethod, 

   577 			 					aSessionType, 

   578 								aIsEmergency, 

   579 								aQuality);

   580 			}			

   581 		else

   582 			{

   583 			// TODO: Return a dummy loc response with error code?

   584 			LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   585 			}

   586 		}

   587 	}

   588 

   589 /** Called when a reference position arrives from the network.

   590 */

   591 void CPrivacyAndLocationHandler::OnNetLocReferenceUpdate(

   592 		const TLbsNetSessionIdInt& aSessionId, 

   593 		const TPositionInfoBase& aPosInfo)

   594 	{

   595 	LBSLOG2(ELogP3, "Received reference position update for id %d", aSessionId.SessionNum());

   596 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   597 	

   598 	if (NULL != fsm)

   599 		{

   600 		fsm->OnNetLocReferenceUpdate(aSessionId, aPosInfo);

   601 		}

   602 	else

   603 		{

   604 		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   605 		}	

   606 	}

   607 

   608 /** Callend when a final location arrives from the network.

   609 */

   610 void CPrivacyAndLocationHandler::OnNetLocFinalUpdate(

   611 		const TLbsNetSessionIdInt& aSessionId, 

   612 		const TPositionInfoBase& aPosInfo)

   613 	{

   614 	LBSLOG2(ELogP3, "Received final network position update for id %d", aSessionId.SessionNum());

   615 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   616 	

   617 	if (NULL != fsm)

   618 		{

   619 		fsm->OnNetLocFinalUpdate(aSessionId, aPosInfo);

   620 		}

   621 	else

   622 		{

   623 		LBSLOG_WARN(ELogP3, "Couldn't find a FSM with matching session Id");

   624 		}

   625 	}

   626 

   627 /** Callback when a GPS position update arrives from AGPS manager.

   628 */

   629 void CPrivacyAndLocationHandler::OnAgpsPositionUpdate(

   630 	TInt aReason,

   631 	const TPositionExtendedSatelliteInfo& aPosInfo,

   632 	const TTime& aTimeStamp)

   633 	{

   634 	// Broadcast the update to all state machines.

   635 	const TInt count = iFsmArray.Count();

   636 	for (TInt i = 0; i < count; i++)

   637 		{

   638 		iFsmArray[i]->OnAgpsPositionUpdate(aReason, aPosInfo, aTimeStamp);

   639 		}

   640 	}

   641 

   642 /** Callback when a GPS measurement results update arrives from AGPS manager.

   643 */

   644 void CPrivacyAndLocationHandler::OnAgpsMeasurementUpdate(

   645 	TInt aReason,

   646 	const TPositionGpsMeasurementInfo& aPosInfo,

   647 	const TTime& aTimeStamp)

   648 	{

   649 	// Broadcast the update to all state machines

   650 	const TInt count = iFsmArray.Count();

   651 	for (TInt i = 0; i < count; i++)

   652 		{

   653 		iFsmArray[i]->OnAgpsMeasurementUpdate(aReason, aPosInfo, aTimeStamp);

   654 		}

   655 	}

   656 

   657 /**

   658 */

   659 CAgpsInterfaceHandler* CPrivacyAndLocationHandler::AgpsHandler()

   660 	{

   661 	return iAgpsInterface;

   662 	}

   663 	

   664 // -----------------------------------------------------------------------------

   665 // CPrivacyAndLocationHandler::DeviceGpsModeCaps

   666 // Description: Return the device mode capabilities

   667 // -----------------------------------------------------------------------------

   668 //

   669 TPositionModuleInfoExtended::TDeviceGpsModeCapabilities CPrivacyAndLocationHandler::DeviceGpsModeCaps()

   670 	{

   671 	return iDeviceGpsModeCaps;

   672 	}

   673 

   674 // -----------------------------------------------------------------------------

   675 // CPrivacyAndLocationHandler::BehaviourMode

   676 // Description: Return the behaviour mode setting

   677 // -----------------------------------------------------------------------------

   678 //

   679 CLbsAdmin::TLbsBehaviourMode CPrivacyAndLocationHandler::BehaviourMode()

   680 	{

   681 	return iLbsBehaviourMode;

   682 	}

   683 

   684 RLbsNetworkRegistrationStatus& CPrivacyAndLocationHandler::NetworkRegistrationStatus()

   685 	{

   686 	return iNetRegStatus;

   687 	}

   688 	

   689 

   690 /**

   691 */

   692 MX3pStatusHandler& CPrivacyAndLocationHandler::X3pStatusHandler()

   693 	{

   694 	return *iAgpsInterface;

   695 	}

   696 

   697 /** Returns ETrue if KLbsSpecialFeatureIntermediateFutileUpdate is on.

   698 @return ETrue if the special feature is on, EFalse otherwise.

   699 */

   700 TBool CPrivacyAndLocationHandler::IsSpecialFeatureIntermediateFutileUpdateOn()

   701 	{

   702 	return iSpecialFeatureIntermediateFutileUpdate;

   703 	}

   704 

   705 // ----------------------------------------------------------------------------- 

   706 // 

   707 // ----------------------- Class CLbsPrivLocStateBase --------------------

   708 //

   709 // This class is not intended for instantiation. Implemented functions are

   710 // those common to multiple derived states

   711 //

   712 // ----------------------------------------------------------------------------- 

   713 //

   714 

   715 // ----------------------------------------------------------------------------- 

   716 // CLbsPrivLocStateBase::OnCancelNetworkLocationRequest

   717 // Description: Pass on a received privacy request cancel to the network gateway, 

   718 // if it relates to the current session. 

   719 // This behaviour is common to states EStateWaitLocationRequest,

   720 // EStateWaitLocationUpdate and EStateWaitPrivacyResponse.

   721 // Other states ignore the event.

   722 // ----------------------------------------------------------------------------- 

   723 //

   724 void CLbsPrivLocStateBase::OnCancelNetworkLocationRequest(const TLbsNetSessionIdInt& aSessionId)

   725 	{

   726 	/* Ignore the cancel if this is an emergency request */

   727 	if(!iFsm->IsEmergency())

   728 		{

   729 		// Also ignore it if the cancel doesn't relate to this session.

   730 		if(aSessionId == iFsm->SessionId())

   731 			{

   732 			iFsm->ExitData().SetExitData(TPrivLocStateExitData::EExitCancelledByPrivacyController, KErrCancel);

   733 			iFsm->ChangeState(CLbsPrivLocFsm::EStateIdle, aSessionId);

   734 			}

   735 		}

   736 	}

   737 

   738 // ----------------------------------------------------------------------------- 

   739 // CLbsPrivLocStateBase::OnEntry

   740 // Description: Handles initialisation actions which are common to multiple states. 

   741 // ----------------------------------------------------------------------------- 

   742 //

   743 void CLbsPrivLocStateBase::OnEntry(const TPrivLocCommonParams& /* aStateParams */)

   744 	{

   745 	// Exit reason should always be explicitly set by a state, 

   746 	// otherwise OnExit() will panic

   747 	iFsm->ExitData().SetExitData(TPrivLocStateExitData::EExitReasonNone, KErrNone);

   748 	}

   749 	

   750 	

   751 // ----------------------------------------------------------------------------- 

   752 // CLbsPrivLocStateBase::OnExit

   753 // Description: Handles exit actions which are common to multiple states. 

   754 // Any exit reason not handled here is delegated to the current state.

   755 // ----------------------------------------------------------------------------- 

   756 //

   757 TBool CLbsPrivLocStateBase::OnExit()

   758 	{

   759 	TBool consumed = ETrue;

   760 	switch(iFsm->iExitData.iExitReason)

   761 		{

   762 		case TPrivLocStateExitData::EExitSessionComplete:

   763 			{

   764 			// Tell the AGPS interface handle this location request has finished.

   765 			AgpsInterface()->StopPositioning(iFsm->SessionId());

   766 

   767 			// Tell the privacy controller this session is finished.

   768 			PrivacyHandler()->ProcessRequestComplete(iFsm->SessionId(),

   769 													 iFsm->ExitData().iExitInfo);

   770 			break;

   771 			}

   772 

   773 		case TPrivLocStateExitData::EExitCancelledByPrivacyController:

   774 			{

   775 			// Send a cancel to the network gateway

   776 			TPositionInfo dummyPosInfo;

   777 			TTime dummyTime;

   778 			TLbsNetPosRequestQualityInt dummyQuality;

   779 			MessageSwitch()->SendNetLocResponse(iFsm->SessionId(),

   780 												iFsm->ExitData().iExitInfo,

   781 												dummyQuality,

   782 												dummyPosInfo,

   783 												dummyTime,

   784 												iFsm->IsEmergency());

   785 			}

   786 			break;

   787 

   788 		case TPrivLocStateExitData::EExitLocReqReceived:

   789 			// No action required - request is issued on entry to next state.

   790 		case TPrivLocStateExitData::EExitPrivacyRequestReceived:

   791 			// No action required, state moves to waiting for loc request.

   792 			{

   793 			consumed = ETrue;

   794 			break;			

   795 			}

   796 			

   797 		default:

   798 			{

   799 			// Don't know what to do with it.

   800 			consumed = EFalse;

   801 			break;							

   802 			}

   803 		}

   804 	return(consumed);

   805 	}

   806 	

   807 // ----------------------------------------------------------------------------- 

   808 // CLbsPrivLocStateBase::HandleLocRequest

   809 // Description: Common handling of a location request received while the 

   810 // Privacy and Location Handler is dealing with a session.

   811 // 

   812 // If the session type is anything but MTLR, then it is processed, otherwise

   813 // a privacy request is generated

   814 // ----------------------------------------------------------------------------- 

   815 //

   816 void CLbsPrivLocStateBase::HandleLocRequest(const TLbsNetSessionIdInt& aSessionId, 

   817 						 const TLbsNetPosRequestMethodInt& aPosRequestMethod,

   818 						 TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   819 						 TBool aIsEmergency,

   820 						 const TLbsNetPosRequestQualityInt& aQuality)

   821 	{

   822 	// MTLR.

   823 	if (aSessionType == TLbsNetworkEnumInt::EServiceMobileTerminated)

   824 		{

   825 		// An MTLR with out a prior privacy request is not supported, report error via

   826 		// RespondLocationRequest(dummy position).

   827 		TPositionInfo dummyPosInfo;

   828 		TTime dummyTime;

   829 		TLbsNetPosRequestQualityInt dummyQuality;

   830 

   831 		MessageSwitch()->SendNetLocResponse(aSessionId,

   832 											KErrNotSupported,

   833 											dummyQuality,

   834 											dummyPosInfo,

   835 											dummyTime, aIsEmergency); 

   836 		}

   837 

   838 	// Network Induced.	

   839 	else if (aSessionType == TLbsNetworkEnumInt::EServiceNetworkInduced)

   840 		{

   841 		// If a request for a position update has been received without

   842 		// a privacy request, then there's nothing to say how the user

   843 		// should be informed or what do do if there is no response.

   844 		// The safest thing is to get the user to confirm (verify)

   845 		// the request, and in the absence of confirmation to reject the

   846 		// request. For emergency requests we notify and accept.

   847 		

   848 		// Store the loc req.

   849 		iFsm->LocReqReceived() = ETrue;

   850 

   851 		iFsm->IsEmergency() = aIsEmergency;

   852 		iFsm->NetRequestQuality() = aQuality;

   853 		iFsm->PosRequestMethod() = aPosRequestMethod;

   854 

   855 

   856 		// The following notification types are chosen based on the emergency and network requests admin status.

   857 		//

   858 		// Emergency = On, Admin = Any, gives ENotifyLocationAccepted 

   859 		// Emergency = Off,	Admin = On, gives ENotifyLocationAccepted

   860 		// Emergency = Off,	Admin = OnButAlwayVerify, gives ENotifyAndVerifyLocationRejectedIfNoResponse

   861 		// Emergency = Off, Admin = Off, N/A the notifier or controller will not be called

   862 		// Emergency = Off, Admin = OffButNotify, gives ENotifyLocationRejected

   863 		TLbsNetPosRequestPrivacyInt requestPrivacy;

   864 		

   865 		requestPrivacy.SetRequestAdvice(TLbsNetPosRequestPrivacyInt::ERequestAdviceNotify);

   866 		requestPrivacy.SetRequestAction(TLbsNetPosRequestPrivacyInt::ERequestActionAllow);

   867 

   868 		// Verifications are rejected after timeout.

   869 		CLbsAdmin::TExternalLocateService externalLocate(CLbsAdmin::EExternalLocateOff);

   870 

   871 		ReadNetworkInducedAdminSetting(externalLocate);

   872 		if ((externalLocate == CLbsAdmin::EExternalLocateOnButAlwaysVerify) && (!aIsEmergency))

   873 			{

   874 	    	requestPrivacy.SetRequestAdvice(TLbsNetPosRequestPrivacyInt::ERequestAdviceVerify);

   875 	    	requestPrivacy.SetRequestAction(TLbsNetPosRequestPrivacyInt::ERequestActionReject);

   876 			}

   877 

   878 		// Similarly, default values have to be assigned to the external request info.

   879 		TLbsExternalRequestInfo requestInfo;

   880 		_LIT8(KUnknownExternalReqInfoField, "");

   881 		requestInfo.SetRequesterId(KUnknownExternalReqInfoField);

   882 		requestInfo.SetClientName(KUnknownExternalReqInfoField);

   883 		requestInfo.SetClientExternalId(KUnknownExternalReqInfoField);

   884 

   885 

   886 		// Process the privacy request.		

   887 		iFsm->ExitData().SetExitData(TPrivLocStateExitData::EExitLocReqReceived, KErrNone);

   888 		

   889 		TPrivLocWaitPrivResponseParams privacyRequestParams(aSessionId, aSessionType, requestInfo, requestPrivacy, aIsEmergency);

   890 		iFsm->ChangeState(CLbsPrivLocFsm::EStateWaitPrivacyResponse, privacyRequestParams);

   891 		}

   892 	

   893 	// All other location requests.

   894 	else

   895 		{

   896 		TPrivLocWaitLocationUpdateParams updateRequestParams(aSessionId,

   897 															aPosRequestMethod,

   898 															aSessionType,

   899 															aIsEmergency,

   900 															aQuality);

   901 		iFsm->ExitData().SetExitData(TPrivLocStateExitData::EExitSessionComplete, KErrCancel);

   902 		iFsm->ChangeState(CLbsPrivLocFsm::EStateWaitLocationUpdate, updateRequestParams);

   903 		}

   904 	}

   905 

   906 // ----------------------------------------------------------------------------- 

   907 // CLbsPrivLocStateBase::OnSessionComplete

   908 // Description: Common handling of a session complete message received other

   909 // than when it is expected as normal session completion.

   910 // ----------------------------------------------------------------------------- 

   911 //

   912 void CLbsPrivLocStateBase::OnSessionComplete(const TLbsNetSessionIdInt& aSessionId,

   913 																TInt aReason)

   914 	{

   915 	if(aSessionId == iFsm->SessionId())

   916 		{

   917 		iFsm->ExitData().SetExitData(TPrivLocStateExitData::EExitSessionComplete, aReason);

   918 		iFsm->ChangeState(CLbsPrivLocFsm::EStateIdle, aSessionId);	            

   919 		}		

   920 	}

   921 

   922 /** Called when a reference position arrives from the network.

   923 */

   924 void CLbsPrivLocStateBase::OnNetLocReferenceUpdate(

   925 		const TLbsNetSessionIdInt& /*aSessionId*/ , 

   926 		const TPositionInfoBase& aPosInfo)

   927 	{

   928 	TLbsNetworkEnumInt::TLbsNetProtocolServiceInt sessionType = iFsm->SessionType();

   929 	__ASSERT_DEBUG((sessionType != MLbsNetworkProtocolObserver::EServiceNone), Panic(ENrhPanicBadParamType));

   930 

   931 	if( ((sessionType == MLbsNetworkProtocolObserver::EServiceNetworkInduced) || 

   932 											   (sessionType == MLbsNetworkProtocolObserver::EServiceMobileTerminated)))

   933 		{

   934 		TPositionInfo posInfo = static_cast<const TPositionInfo&>(aPosInfo);

   935 		

   936 		// Set the module Id and position mode for the reference position.

   937 		// These values are not 'real' values, since this position

   938 		// came directly from the network and not one of the location

   939 		// managers within LBS.

   940 		posInfo.SetModuleId(KLbsGpsLocManagerUid);

   941 		posInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   942 		posInfo.SetPositionModeReason(EPositionModeReasonNone);

   943 		posInfo.SetUpdateType(EPositionUpdateGeneral);

   944 		

   945 		if (!iFsm->RefPosProcessed())

   946 			{

   947 			iFsm->RefPosProcessed() = ETrue;

   948 			PrivacyHandler()->ProcessNetworkPositionUpdate(iFsm->SessionId(), posInfo);

   949 			}

   950 

   951 		}	

   952 	}

   953 

   954 /* Timer callback called when the MaxFixTime for a gps location update request has expired. 

   955 

   956 The default action is to ignore this callback. Any state interested in it must

   957 implement its own version.

   958 */

   959 void CLbsPrivLocStateBase::OnTimerEventL(TInt /*aTimerId*/)

   960 	{

   961 	}

   962 

   963 

   964 // ----------------------------------------------------------------------------- 

   965 // CLbsPrivLocStateBase::ReadNetworkInducedAdminSetting

   966 // Description: Determine the external location value from the admin settings for network induced location requests.

   967 // ----------------------------------------------------------------------------- 

   968 //

   969 void CLbsPrivLocStateBase::ReadNetworkInducedAdminSetting(CLbsAdmin::TExternalLocateService& aExternalLocateService)

   970 	{

   971 	CLbsAdmin::TExternalLocateService serviceStatus(CLbsAdmin::EExternalLocateOff);

   972 	RLbsNetworkRegistrationStatus::TLbsNetworkRegistrationStatus netRegStatus(RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown);	

   973 	TInt err = LbsNetworkRegistrationStatus().GetNetworkRegistrationStatus(netRegStatus);

   974 	if (err == KErrNone)

   975 		{

   976 		switch (netRegStatus)

   977 			{

   978 			case RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork:

   979 				{

   980 				err = LbsAdmin()->Get(KLbsSettingHomeNetworkInducedLocate, serviceStatus);

   981 				break;

   982 				}

   983 			case RLbsNetworkRegistrationStatus::ERegisteredRoamingNetwork:

   984 			case RLbsNetworkRegistrationStatus::ENotRegistered:

   985 				{

   986 				err = LbsAdmin()->Get(KLbsSettingRoamingNetworkInducedLocate, serviceStatus);

   987 				break;

   988 				}		

   989 			case RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown:

   990 			default:

   991 				{

   992 				LBSLOG_WARN2(ELogP4, "Unrecognised TLbsNetworkRegistrationStatus (%d), defaulting to EExternalLocateOff",

   993 							 netRegStatus);

   994 				serviceStatus = CLbsAdmin::EExternalLocateOff;

   995 				break;

   996 				}

   997 			}

   998 		}

   999 	else

  1000 		{

  1001 		LBSLOG_WARN2(ELogP4, "Failed to get TExternalLocateService, couldn't read roaming status (err %d), defaulting to EExternalLocateOff",  

  1002 					 err);		

  1003 		}

  1004 	

  1005 	aExternalLocateService = serviceStatus;

  1006 	}

  1007 

  1008 // ----------------------------------------------------------------------------- 

  1009 // CLbsPrivLocStateBase::CLbsPrivLocStateBase

  1010 // Description: Constructor

  1011 // ----------------------------------------------------------------------------- 

  1012 //

  1013 CLbsPrivLocStateBase::CLbsPrivLocStateBase(CLbsPrivLocFsm* aFsm)

  1014 :	iFsm(aFsm)

  1015 	{	

  1016 	}

  1017 // ----------------------------------------------------------------------------- 

  1018 // CLbsPrivLocStateBase::PrivacyHandler, MessageSwitch, LbsAdmin

  1019 // Description: Allows concrete states access to NRH resources passed to

  1020 // the FSM

  1021 // Returns: pointers.

  1022 // ----------------------------------------------------------------------------- 

  1023 //

  1024 CPrivacyHandler* CLbsPrivLocStateBase::PrivacyHandler()

  1025 	{

  1026 	return iFsm->PrivLocHandler().PrivacyHandler();

  1027 	}

  1028 CNGMessageSwitch* CLbsPrivLocStateBase::MessageSwitch()

  1029 	{

  1030 	return iFsm->PrivLocHandler().MessageSwitch();

  1031 	}

  1032 CLbsAdmin* CLbsPrivLocStateBase::LbsAdmin()

  1033 	{

  1034 	return iFsm->PrivLocHandler().LbsAdmin();

  1035 	}

  1036 CAgpsInterfaceHandler* CLbsPrivLocStateBase::AgpsInterface()

  1037 	{

  1038 	return iFsm->PrivLocHandler().AgpsHandler();

  1039 	}

  1040 

  1041 

  1042 TPositionModuleInfoExtended::TDeviceGpsModeCapabilities CLbsPrivLocStateBase::DeviceGpsModeCaps()

  1043 	{

  1044 	return iFsm->PrivLocHandler().DeviceGpsModeCaps();

  1045 	}

  1046 

  1047 CLbsAdmin::TLbsBehaviourMode CLbsPrivLocStateBase::BehaviourMode()

  1048 	{

  1049 	return iFsm->PrivLocHandler().BehaviourMode();

  1050 	}

  1051 

  1052 RLbsNetworkRegistrationStatus& CLbsPrivLocStateBase::LbsNetworkRegistrationStatus()

  1053 	{

  1054 	return iFsm->PrivLocHandler().NetworkRegistrationStatus();

  1055 	}

  1056 

  1057 // ----------------------------------------------------------------------------- 

  1058 // 

  1059 // ----------------------- Class CLbsPrivLocIdleState --------------------

  1060 //

  1061 // Implements the Idle state of the Privacy and Location Request Handler

  1062 //

  1063 // ----------------------------------------------------------------------------- 

  1064 //

  1065 

  1066 // ----------------------------------------------------------------------------- 

  1067 // CLbsPrivLocIdleState::NewL

  1068 // Description: CLbsPrivLocIdleState static constructor 

  1069 // ----------------------------------------------------------------------------- 

  1070 //

  1071 CLbsPrivLocIdleState* CLbsPrivLocIdleState::NewL(CLbsPrivLocFsm* aFsm)

  1072 	{

  1073 	return new (ELeave) CLbsPrivLocIdleState(aFsm);

  1074 	}

  1075 	

  1076 // ----------------------------------------------------------------------------- 

  1077 // CLbsPrivLocIdleState::CLbsPrivLocIdleState

  1078 // Description: CLbsPrivLocIdleState constructor.

  1079 // ----------------------------------------------------------------------------- 

  1080 //

  1081 CLbsPrivLocIdleState::CLbsPrivLocIdleState(CLbsPrivLocFsm* aFsm) 

  1082 : CLbsPrivLocStateBase(aFsm)

  1083 	{

  1084 	}

  1085 

  1086 // ----------------------------------------------------------------------------- 

  1087 // CLbsPrivLocIdleState::OnEntry

  1088 // Description: Carries out tasks required on entry to the state.

  1089 // ----------------------------------------------------------------------------- 

  1090 //

  1091 void CLbsPrivLocIdleState::OnEntry(const TPrivLocCommonParams& aStateParams)

  1092 	{

  1093 	CLbsPrivLocStateBase::OnEntry(aStateParams);

  1094 	}

  1095 

  1096 // ----------------------------------------------------------------------------- 

  1097 // CLbsPrivLocIdleState::OnExit

  1098 // Description: Carries out tasks required on exit from the state.

  1099 // Panics if the exit reason is not handled by the base state exit

  1100 // ----------------------------------------------------------------------------- 

  1101 //

  1102 TBool CLbsPrivLocIdleState::OnExit()

  1103 	{

  1104 	TBool consumed = CLbsPrivLocStateBase::OnExit();

  1105 	// If the exit reason wasn't handled, panic (should only happen in development)

  1106 	__ASSERT_DEBUG(consumed, Panic(ENrhPanicIdleUnknownExitReason));

  1107 	

  1108 	return(consumed);

  1109 	}

  1110 	

  1111 // ----------------------------------------------------------------------------- 

  1112 // CLbsPrivLocIdleState::OnNetLocRequest

  1113 // Description: The Message Switch has forwarded a request for a control 

  1114 // measurement.

  1115 // If the session type is anything but MTLR, then it is processed, otherwise

  1116 // a privacy request is generated

  1117 // ----------------------------------------------------------------------------- 

  1118 //

  1119 void CLbsPrivLocIdleState::OnNetLocRequest(

  1120 		const TLbsNetSessionIdInt& aSessionId,

  1121 		const TLbsNetPosRequestMethodInt& aPosRequestMethod,

  1122 		TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

  1123 		TBool aIsEmergency,

  1124         const TLbsNetPosRequestQualityInt& aQuality)

  1125     {

  1126     iFsm->SessionType() = aSessionType;

  1127     if(iFsm->WasPrivacyResponseReceivedStateExited())

  1128         {

  1129         // The request relates to a rejected privacy request

  1130         // or a request for this session which has already been answered. 

  1131         // In either case, it should be refused. The message is sent to the

  1132         // network gateway as apart of exit from the state, but we want to 

  1133         // remain in Idle state.