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 #include <centralrepository.h>

    19 

    20 #ifdef SYMBIAN_FEATURE_MANAGER

    21     #include <featdiscovery.h>

    22     #include <featureuids.h>

    23 #endif

    24 

    25 // LBS-specific

    26 #include <lbs.h>

    27 #include <lbs/lbsadmin.h>

    28 #include <lbs/lbslocerrors.h>

    29 #include <lbs/lbslocclasstypes.h>

    30 

    31 #include "nrhpanic.h"

    32 #include "lbsdevloggermacros.h"

    33 #include "lbsqualityprofile.h"

    34 #include "lbsrootcenrepdefs.h"

    35 #include "lbspositioningstatusprops.h"

    36 

    37 #include "privacyandlocationrequesthandler.h"

    38 

    39 // Special 'invalid session' SessionId.

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

    41 

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

    43 																	TPositionModuleInfo::ETechnologyAssisted);

    44 	

    45 // ----------------------------------------------------------------------------- 

    46 // 

    47 // ----------------------- Class CPrivacyAndLocationHandler --------------------

    48 //

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

    50 //

    51 // ----------------------------------------------------------------------------- 

    52 //

    53 

    54 // ----------------------------------------------------------------------------- 

    55 // CPrivacyAndLocationHandler::NewL

    56 // Description: CPrivacyAndLocationHandler static constructor 

    57 // ----------------------------------------------------------------------------- 

    58 //

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

    60 											CLbsAdmin& aLbsAdmin,

    61 											RLbsNetworkRegistrationStatus& aNetRegStatus)

    62 	{

    63 	CPrivacyAndLocationHandler* self; 

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

    65 	CleanupStack::PushL(self);

    66 	self->ConstructL(&aLbsAdmin);

    67 	CleanupStack::Pop(self);

    68 	return(self);	

    69 	}

    70 

    71 // ----------------------------------------------------------------------------- 

    72 // CPrivacyAndLocationHandler::CPrivacyAndLocationHandler

    73 // Description: CPrivacyAndLocationHandler constructor 

    74 // ----------------------------------------------------------------------------- 

    75 //

    76 CPrivacyAndLocationHandler::CPrivacyAndLocationHandler(CNGMessageSwitch& aMessageSwitch, 

    77 													   RLbsNetworkRegistrationStatus& aNetRegStatus)

    78 :	iNetRegStatus(aNetRegStatus),

    79 	iMessageSwitch(&aMessageSwitch),

    80 	iNumActiveSessions(0)

    81 	{	

    82 	}

    83 	

    84 // ----------------------------------------------------------------------------- 

    85 // CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler

    86 // Description: CPrivacyAndLocationHandler destructor 

    87 // ----------------------------------------------------------------------------- 

    88 //

    89 CPrivacyAndLocationHandler::~CPrivacyAndLocationHandler()

    90 	{

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

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

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

    94 	// is called.

    95 			

    96 	TInt index = iFsmArray.Find(iEmergencyFsm);

    97 	if (index >= 0)

    98 		{

    99 		iFsmArray.Remove(index);

   100 		}

   101 	

   102 	iFsmArray.ResetAndDestroy();

   103 

   104     // force the count of active network initiated positioning sessions to 0

   105 	// this supports the pre-APE centric architecture wherein the NRH is

   106 	// destroyed on completion of network initiated positioning. 

   107     RProperty::Set(iPosStatusCategory, KLbsNiPositioningStatusKey, 0);

   108 

   109 	delete iEmergencyFsm;

   110     delete iAgpsInterface;

   111     delete iPrivacyHandler;

   112 	}

   113 

   114 // ----------------------------------------------------------------------------- 

   115 // CPrivacyAndLocationHandler::ConstructL

   116 // Description: CPrivacyAndLocationHandler second-phase constructor.

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

   118 // ----------------------------------------------------------------------------- 

   119 //

   120 

   121 const TInt KLbsDefaultMaxNumLocationRequests   = 4;

   122 

   123 void CPrivacyAndLocationHandler::ConstructL(CLbsAdmin* aLbsAdmin)

   124 	{

   125 	iLbsAdmin = aLbsAdmin;

   126 	

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

   128 	iMessageSwitch->RegisterObserver(this);

   129 

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

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

   132 	if (err != KErrNone)

   133 		{

   134 		iLbsBehaviourMode = CLbsAdmin::ELbsBehaviourCustom1;

   135 		}

   136 	// get device mode capabilities:

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

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

   139 		{

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

   141 		iDeviceGpsModeCaps = TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB;

   142 		}

   143 

   144 

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

   146 	if (err != KErrNone)

   147 		{

   148 		iMaxNumSessions = KLbsDefaultMaxNumLocationRequests;

   149 		}

   150 	

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

   152 

   153 

   154 #ifdef NRH_UNIT_TEST

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

   156 	const TInt KTestNgUidInt = 0x1028226B;

   157 	const TUid KTestNgUid = {KTestNgUidInt};

   158 	iProtocolModuleUid = KTestNgUid;

   159 #else

   160 	ReadProtocolModuleAdminSetting();

   161 #endif

   162 	

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

   164 	

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

   166 	iFsmArray.ReserveL(iMaxNumSessions+1);

   167 

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

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

   170 	if (err != KErrNone)

   171 		{

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

   173 		}

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

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

   176 	

   177 #ifdef SYMBIAN_FEATURE_MANAGER

   178     iLocationManagementSupported = CFeatureDiscovery::IsFeatureSupportedL(NFeature::KLocationManagement);

   179 #else

   180     __ASSERT_ALWAYS(EFalse, User::Invariant()); // Would happen on older versions of symbian OS if this code ever backported

   181 #endif    

   182     

   183     // Get the CategoryUid from the cenrep file owned by LbsRoot for accessing Positioning Status P&S Keys

   184     CRepository* rep = CRepository::NewLC(KLbsCenRepUid);

   185     TInt posStatusCategory;

   186     err = rep->Get(KNiPositioningStatusAPIKey, posStatusCategory);

   187     User::LeaveIfError(err);

   188     CleanupStack::PopAndDestroy(rep);

   189     iPosStatusCategory = TUid::Uid(posStatusCategory);

   190 	}

   191 

   192 

   193 

   194 /**

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

   196 */

   197 void CPrivacyAndLocationHandler::ReadProtocolModuleAdminSetting()

   198 	{

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

   200 	TLbsProtocolModuleId protUid(KLbsProtocolNullModuleId);

   201 	

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

   203 	if (err != KErrNone)

   204 		{

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

   206 		}

   207 

   208 	iProtocolModuleUid = protUid;

   209 	}

   210 

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

   212 */

   213 TBool CPrivacyAndLocationHandler::IsSessionIdEqual(

   214 		const TLbsNetSessionIdInt* aSessionId,

   215 		const CLbsPrivLocFsm& aFsm)

   216 	{

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

   218 	}

   219 

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

   221 */

   222 TBool CPrivacyAndLocationHandler::IsSessionTypeEqual(

   223 		const TLbsNetworkEnumInt::TLbsNetProtocolServiceInt* aSessionType,

   224 		const CLbsPrivLocFsm& aFsm)

   225 	{

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

   227 	}

   228 

   229 // ----------------------------------------------------------------------------- 

   230 // CPrivacyAndLocationHandler::LookupFsm

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

   232 // ----------------------------------------------------------------------------- 

   233 //

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

   235 	{

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

   237 

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

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

   240 	if (index >= 0)

   241 		{

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

   243 		return iFsmArray[index];

   244 		}

   245 	else

   246 		{

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

   248 		return NULL;		

   249 		}

   250 	}

   251 

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

   253 

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

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

   256 */

   257 CLbsPrivLocFsm* CPrivacyAndLocationHandler::GetNewFsm(

   258 		const TLbsNetSessionIdInt& aSessionId,

   259 		TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType,

   260 		TBool aEmergency)

   261 	{

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

   263 	

   264 	CLbsPrivLocFsm* fsm(NULL);

   265 

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

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

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

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

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

   271 	if (aEmergency

   272 		&& (aSessionType == MLbsNetworkProtocolObserver::EServiceMobileTerminated

   273 		|| aSessionType == MLbsNetworkProtocolObserver::EServiceNetworkInduced))

   274 		{					

   275 		TInt index = iFsmArray.Find(iEmergencyFsm);

   276 		if (index >= 0)

   277 			{

   278 			iFsmArray.Remove(index);

   279 			iNumActiveSessions--;

   280 			}

   281 		// clean out Fsm

   282 		iEmergencyFsm->RefPosProcessed() = EFalse;

   283 		iEmergencyFsm->LocReqReceived() = EFalse;

   284 		iEmergencyFsm->LocationFixReceived()= EFalse;

   285 		iEmergencyFsm->TapMode() = EFalse;

   286 		iEmergencyFsm->WasPrivacyResponseReceivedStateExited() = EFalse;

   287 		iEmergencyFsm->NetSessionId()= aSessionId;

   288 		fsm = iEmergencyFsm;

   289 		}

   290 	else

   291 		{

   292 		if (iNumActiveSessions <= iMaxNumSessions)

   293 			{

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

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

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

   297 			if (err != KErrNone)

   298 				{

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

   300 				}

   301 			}

   302 		else

   303 			{

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

   305 			}

   306 		}

   307 

   308 	if (fsm)

   309 		{

   310 		// Add the state machine to the buffer.

   311 		iFsmArray.Append(fsm);

   312 	

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

   314 

   315 		}

   316 	

   317 	return fsm;

   318 	}

   319 

   320 

   321 // ----------------------------------------------------------------------------- 

   322 // CPrivacyAndLocationHandler::PrivacyHandler

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

   324 //              (controller or notifier).

   325 // ----------------------------------------------------------------------------- 

   326 //

   327 CPrivacyHandler* CPrivacyAndLocationHandler::PrivacyHandler()

   328 	{

   329 	return iPrivacyHandler;

   330 	}

   331 	

   332 // ----------------------------------------------------------------------------- 

   333 // CPrivacyAndLocationHandler::MessageSwitch

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

   335 // ----------------------------------------------------------------------------- 

   336 //

   337 CNGMessageSwitch* CPrivacyAndLocationHandler::MessageSwitch()

   338 	{

   339 	return iMessageSwitch;

   340 	}

   341 	

   342 // ----------------------------------------------------------------------------- 

   343 // CPrivacyAndLocationHandler::LbsAdmin

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

   345 // ----------------------------------------------------------------------------- 

   346 //

   347 CLbsAdmin* CPrivacyAndLocationHandler::LbsAdmin()

   348 	{

   349 	return iLbsAdmin;

   350 	}

   351 	

   352 // ----------------------------------------------------------------------------- 

   353 // CPrivacyAndLocationHandler::SetServerObserver

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

   355 // Privacy Controller.

   356 // ----------------------------------------------------------------------------- 

   357 //

   358 void CPrivacyAndLocationHandler::SetServerObserver(MLbsSessionObserver* aNrhServer)

   359     {

   360     PrivacyHandler()->SetServerObserver(aNrhServer);

   361     }

   362 

   363 // ----------------------------------------------------------------------------- 

   364 // CPrivacyAndLocationHandler::OnRespondNetworkLocationRequest

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

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

   367 // ----------------------------------------------------------------------------- 

   368 //

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

   370                             TLbsNetworkEnumInt::TLbsPrivacyResponseInt aRequestResult,

   371                             TInt aResponseReason)

   372 	{

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

   374 	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

   375 	

   376 	if (NULL != fsm)

   377 		{

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

   379 		}

   380 	else

   381 		{

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

   383 		}

   384     }

   385 

   386 // ----------------------------------------------------------------------------- 

   387 // CPrivacyAndLocationHandler::OnCancelNetworkLocationRequest

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

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

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

   391 // ----------------------------------------------------------------------------- 

   392 //

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

   394     {

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

   396 	CLbsPrivLocFsm* fsm = LookupFsm(aRequestId);

   397 	

   398 	if (NULL != fsm)

   399 		{

   400 		fsm->OnCancelNetworkLocationRequest(aRequestId);

   401 		}

   402 	else

   403 		{

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

   405 		}

   406     }

   407 

   408 // ----------------------------------------------------------------------------- 

   409 // CPrivacyAndLocationHandler::OnMTLRRequest

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

   411 // session.

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

   413 // ----------------------------------------------------------------------------- 

   414 //

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

   416 					   TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   417 					   TBool aIsEmergency,

   418 					   const TLbsExternalRequestInfo& aExternalRequestInfo,

   419 					   const TLbsNetPosRequestPrivacyInt& aNetPosRequestPrivacy)

   420 	{

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

   422 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   423 

   424 	if (fsm==NULL)

   425 		{

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

   427 		}

   428 	

   429 	if (NULL != fsm)

   430 		{

   431 		fsm->OnMTLRRequest(aSessionId, 

   432 						   aSessionType, 

   433 						   aIsEmergency, 

   434 						   aExternalRequestInfo, 

   435 						   aNetPosRequestPrivacy);

   436 		}

   437 	else

   438 		{					

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

   440 		// so simply reply with a privacy rejection.

   441 		iMessageSwitch->SendMTLRResponse(aSessionId, 

   442 										 TLbsNetworkEnumInt::EPrivacyResponseRejected,

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

   444 		}

   445 	}

   446 	

   447 // ----------------------------------------------------------------------------- 

   448 // CPrivacyAndLocationHandler::OnSessionComplete

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

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

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

   452 // ----------------------------------------------------------------------------- 

   453 //

   454 void CPrivacyAndLocationHandler::OnSessionComplete(

   455 									const TLbsNetSessionIdInt& aSessionId,

   456 									TInt aReason)

   457 	{

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

   459 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   460 	

   461 	if (NULL != fsm)

   462 		{

   463 		fsm->OnSessionComplete(aSessionId, aReason);

   464 

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

   466 		TInt index = iFsmArray.Find(fsm);

   467 		if (index != KErrNotFound)

   468 			{ 

   469 			

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

   471 				{

   472 				iMolRFsm = NULL;

   473 				}

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

   475 				{

   476 				iX3pFsm = NULL;

   477 				}

   478 			

   479 			// We should never delete the emergency FSM.

   480 			iFsmArray.Remove(index);

   481 			iNumActiveSessions--;

   482 			

   483 			if (fsm != iEmergencyFsm)

   484 				{

   485 				delete fsm;

   486 				}

   487 			}

   488 		}

   489 	else

   490 		{

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

   492 		}

   493 	}

   494 

   495 // ----------------------------------------------------------------------------- 

   496 // CPrivacyAndLocationHandler::OnNetLocRequest

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

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

   499 // ----------------------------------------------------------------------------- 

   500 //

   501 void CPrivacyAndLocationHandler::OnNetLocRequest(

   502 						const TLbsNetSessionIdInt& aSessionId, 

   503 						const TLbsNetPosRequestMethodInt& aPosRequestMethod,

   504 						TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   505 						TBool aIsEmergency,

   506 						const TLbsNetPosRequestQualityInt& aQuality)

   507 	{

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

   509 	

   510 	TLbsNetSessionIdInt sessionId;

   511 	TPositionInfo    posInfo;

   512 	TPosition		 pos;

   513 	TTime 			 timeStamp;

   514 	TInt 			 err;

   515 	

   516 	TBool tapMode = EFalse;

   517 	TInt numMethods = aPosRequestMethod.NumPosMethods();

   518     if (numMethods==1)

   519     	{

   520     	TLbsNetPosMethodInt netPosMethod;

   521     	aPosRequestMethod.GetPosMethod(0,netPosMethod);

   522                  

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

   524     		{

   525     		tapMode = ETrue;

   526     		}

   527     	}

   528 	

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

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

   531 	

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

   533 		{

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

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

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

   537 		// controller aren't interested.

   538 		// Simply return the saved reference location

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

   540 		posInfo.GetPosition(pos);

   541 		timeStamp = pos.Time();

   542 		TLbsNetPosRequestQualityInt dummyQuality;

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

   544 		}

   545 	else

   546 		{

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

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

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

   550 		// fsm for the new client 

   551 		CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   552 		if (!fsm)

   553 			{

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

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

   556 			// a new one will implicitly cancel any ongoing

   557 			if(aSessionType == TLbsNetworkEnumInt::EServiceSelfLocation)

   558 				{

   559 				if (iMolRFsm)

   560 					{

   561 					TInt index = iFsmArray.Find(iMolRFsm);

   562 					if (index != KErrNotFound)

   563 						{ 

   564 						iFsmArray.Remove(index);

   565 						iNumActiveSessions--;

   566 						delete iMolRFsm;

   567 						iMolRFsm = NULL;

   568 						}

   569 					}

   570 					

   571 				}

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

   573 				{

   574 				if (iX3pFsm)

   575 					{

   576 					TInt index = iFsmArray.Find(iX3pFsm);

   577 					if (index != KErrNotFound)

   578 						{ 

   579 						iFsmArray.Remove(index);

   580 						iNumActiveSessions--;

   581 						delete iX3pFsm;

   582 						iX3pFsm = NULL;

   583 						}

   584 					}

   585 				}

   586 				

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

   588 			}

   589 		

   590 		if (NULL != fsm)

   591 			{

   592 			if(aSessionType == TLbsNetworkEnumInt::EServiceSelfLocation)

   593 				{

   594 				iMolRFsm = fsm;

   595 				}

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

   597 				{

   598 				iX3pFsm = fsm;

   599 				}

   600 			

   601 			fsm->OnNetLocRequest(aSessionId,

   602 					aPosRequestMethod, 

   603 			 					aSessionType, 

   604 								aIsEmergency, 

   605 								aQuality);

   606 			}			

   607 		else

   608 			{

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

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

   611 			}

   612 		}

   613 	}

   614 

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

   616 */

   617 void CPrivacyAndLocationHandler::OnNetLocReferenceUpdate(

   618 		const TLbsNetSessionIdInt& aSessionId, 

   619 		const TPositionInfoBase& aPosInfo)

   620 	{

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

   622 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   623 	

   624 	if (NULL != fsm)

   625 		{

   626 		fsm->OnNetLocReferenceUpdate(aSessionId, aPosInfo);

   627 		}

   628 	else

   629 		{

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

   631 		}	

   632 	}

   633 

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

   635 */

   636 void CPrivacyAndLocationHandler::OnNetLocFinalUpdate(

   637 		const TLbsNetSessionIdInt& aSessionId, 

   638 		const TPositionInfoBase& aPosInfo)

   639 	{

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

   641 	CLbsPrivLocFsm* fsm = LookupFsm(aSessionId);

   642 	

   643 	if (NULL != fsm)

   644 		{

   645 		fsm->OnNetLocFinalUpdate(aSessionId, aPosInfo);

   646 		}

   647 	else

   648 		{

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

   650 		}

   651 	}

   652 

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

   654 */

   655 void CPrivacyAndLocationHandler::OnAgpsPositionUpdate(

   656 	TInt aReason,

   657 	const TPositionExtendedSatelliteInfo& aPosInfo,

   658 	const TTime& aTimeStamp)

   659 	{

   660 	// Broadcast the update to all state machines.

   661 	const TInt count = iFsmArray.Count();

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

   663 		{

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

   665 		}

   666 	}

   667 

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

   669 */

   670 void CPrivacyAndLocationHandler::OnAgpsMeasurementUpdate(

   671 	TInt aReason,

   672 	const TPositionGpsMeasurementInfo& aPosInfo,

   673 	const TTime& aTimeStamp)

   674 	{

   675 	// Broadcast the update to all state machines

   676 	const TInt count = iFsmArray.Count();

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

   678 		{

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

   680 		}

   681 	}

   682 

   683 /**

   684 */

   685 CAgpsInterfaceHandler* CPrivacyAndLocationHandler::AgpsHandler()

   686 	{

   687 	return iAgpsInterface;

   688 	}

   689 	

   690 // -----------------------------------------------------------------------------

   691 // CPrivacyAndLocationHandler::DeviceGpsModeCaps

   692 // Description: Return the device mode capabilities

   693 // -----------------------------------------------------------------------------

   694 //

   695 TPositionModuleInfoExtended::TDeviceGpsModeCapabilities CPrivacyAndLocationHandler::DeviceGpsModeCaps()

   696 	{

   697 	return iDeviceGpsModeCaps;

   698 	}

   699 

   700 // -----------------------------------------------------------------------------

   701 // CPrivacyAndLocationHandler::BehaviourMode

   702 // Description: Return the behaviour mode setting

   703 // -----------------------------------------------------------------------------

   704 //

   705 CLbsAdmin::TLbsBehaviourMode CPrivacyAndLocationHandler::BehaviourMode()

   706 	{

   707 	return iLbsBehaviourMode;

   708 	}

   709 

   710 RLbsNetworkRegistrationStatus& CPrivacyAndLocationHandler::NetworkRegistrationStatus()

   711 	{

   712 	return iNetRegStatus;

   713 	}

   714 

   715 // increments the P&S key tracking mobile terminated positioning requests

   716 void CPrivacyAndLocationHandler::IncrementPositioningStatus()

   717     {

   718     TInt count;     

   719     RProperty::Get(iPosStatusCategory, KLbsNiPositioningStatusKey, count);

   720     RProperty::Set(iPosStatusCategory, KLbsNiPositioningStatusKey, count+1);

   721     }

   722 

   723 // decrements the P&S key tracking mobile terminated positioning requests

   724 // if location management is supported. In the alternative architecture,

   725 // the NRH is not aware of the positioning session's progress, but is 

   726 // transient. Therefore the positioning status is set to zero in the 

   727 // class destructor.

   728 void CPrivacyAndLocationHandler::DecrementPositioningStatus()

   729     {

   730     if (iLocationManagementSupported)

   731         {

   732         TInt count;     

   733         RProperty::Get(iPosStatusCategory, KLbsNiPositioningStatusKey, count);

   734         if(count>0)

   735             {

   736             RProperty::Set(iPosStatusCategory, KLbsNiPositioningStatusKey, count-1);

   737             }

   738         else

   739             {

   740             LBSLOG_ERR(ELogP3, "CPrivacyAndLocationHandler::DecrementPositioningStatus() - Incorrect Positioning Status count\n");

   741             }

   742         }

   743     }

   744 	

   745 

   746 /**

   747 */

   748 MX3pStatusHandler& CPrivacyAndLocationHandler::X3pStatusHandler()

   749 	{

   750 	return *iAgpsInterface;

   751 	}

   752 

   753 /** Returns ETrue if KLbsSpecialFeatureIntermediateFutileUpdate is on.

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

   755 */

   756 TBool CPrivacyAndLocationHandler::IsSpecialFeatureIntermediateFutileUpdateOn()

   757 	{

   758 	return iSpecialFeatureIntermediateFutileUpdate;

   759 	}

   760 

   761 // ----------------------------------------------------------------------------- 

   762 // 

   763 // ----------------------- Class CLbsPrivLocStateBase --------------------

   764 //

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

   766 // those common to multiple derived states

   767 //

   768 // ----------------------------------------------------------------------------- 

   769 //

   770 

   771 // ----------------------------------------------------------------------------- 

   772 // CLbsPrivLocStateBase::OnCancelNetworkLocationRequest

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

   774 // if it relates to the current session. 

   775 // This behaviour is common to states EStateWaitLocationRequest,

   776 // EStateWaitLocationUpdate and EStateWaitPrivacyResponse.

   777 // Other states ignore the event.

   778 // ----------------------------------------------------------------------------- 

   779 //

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

   781 	{

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

   783 	if(!iFsm->IsEmergency())

   784 		{

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

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

   787 			{

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

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

   790 			}

   791 		}

   792 	}

   793 

   794 // ----------------------------------------------------------------------------- 

   795 // CLbsPrivLocStateBase::OnEntry

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

   797 // ----------------------------------------------------------------------------- 

   798 //

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

   800 	{

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

   802 	// otherwise OnExit() will panic

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

   804 	}

   805 	

   806 	

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

   808 // CLbsPrivLocStateBase::OnExit

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

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

   811 // ----------------------------------------------------------------------------- 

   812 //

   813 TBool CLbsPrivLocStateBase::OnExit()

   814 	{

   815 	TBool consumed = ETrue;

   816 	switch(iFsm->iExitData.iExitReason)

   817 		{

   818 		case TPrivLocStateExitData::EExitSessionComplete:

   819 			{

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

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

   822 

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

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

   825 													 iFsm->ExitData().iExitInfo);

   826 			break;

   827 			}

   828 

   829 		case TPrivLocStateExitData::EExitCancelledByPrivacyController:

   830 			{

   831 			// Send a cancel to the network gateway

   832 			TPositionInfo dummyPosInfo;

   833 			TTime dummyTime;

   834 			TLbsNetPosRequestQualityInt dummyQuality;

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

   836 												iFsm->ExitData().iExitInfo,

   837 												dummyQuality,

   838 												dummyPosInfo,

   839 												dummyTime,

   840 												iFsm->IsEmergency());

   841 			}

   842 			break;

   843 

   844 		case TPrivLocStateExitData::EExitLocReqReceived:

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

   846 		case TPrivLocStateExitData::EExitPrivacyRequestReceived:

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

   848 			{

   849 			consumed = ETrue;

   850 			break;			

   851 			}

   852 			

   853 		default:

   854 			{

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

   856 			consumed = EFalse;

   857 			break;							

   858 			}

   859 		}

   860 	return(consumed);

   861 	}

   862 	

   863 // ----------------------------------------------------------------------------- 

   864 // CLbsPrivLocStateBase::HandleLocRequest

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

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

   867 // 

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

   869 // a privacy request is generated

   870 // ----------------------------------------------------------------------------- 

   871 //

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

   873 						 const TLbsNetPosRequestMethodInt& aPosRequestMethod,

   874 						 TLbsNetworkEnumInt::TLbsNetProtocolServiceInt aSessionType, 

   875 						 TBool aIsEmergency,

   876 						 const TLbsNetPosRequestQualityInt& aQuality)

   877 	{

   878 	// MTLR.

   879 	if (aSessionType == TLbsNetworkEnumInt::EServiceMobileTerminated)

   880 		{

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

   882 		// RespondLocationRequest(dummy position).

   883 		TPositionInfo dummyPosInfo;

   884 		TTime dummyTime;

   885 		TLbsNetPosRequestQualityInt dummyQuality;

   886 

   887 		MessageSwitch()->SendNetLocResponse(aSessionId,

   888 											KErrNotSupported,

   889 											dummyQuality,

   890 											dummyPosInfo,

   891 											dummyTime, aIsEmergency); 

   892 		}

   893 

   894 	// Network Induced.	

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

   896 		{

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

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

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

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

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

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

   903 		

   904 		// Store the loc req.

   905 		iFsm->LocReqReceived() = ETrue;

   906 

   907 		iFsm->IsEmergency() = aIsEmergency;

   908 		iFsm->NetRequestQuality() = aQuality;

   909 		iFsm->PosRequestMethod() = aPosRequestMethod;

   910 

   911 

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

   913 		//

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

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

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

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

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

   919 		TLbsNetPosRequestPrivacyInt requestPrivacy;

   920 		

   921 		requestPrivacy.SetRequestAdvice(TLbsNetPosRequestPrivacyInt::ERequestAdviceNotify);

   922 		requestPrivacy.SetRequestAction(TLbsNetPosRequestPrivacyInt::ERequestActionAllow);

   923 

   924 		// Verifications are rejected after timeout.

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

   926 

   927 		ReadNetworkInducedAdminSetting(externalLocate);

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

   929 			{

   930 	    	requestPrivacy.SetRequestAdvice(TLbsNetPosRequestPrivacyInt::ERequestAdviceVerify);

   931 	    	requestPrivacy.SetRequestAction(TLbsNetPosRequestPrivacyInt::ERequestActionReject);

   932 			}

   933 

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

   935 		TLbsExternalRequestInfo requestInfo;

   936 		_LIT8(KUnknownExternalReqInfoField, "");

   937 		requestInfo.SetRequesterId(KUnknownExternalReqInfoField);

   938 		requestInfo.SetClientName(KUnknownExternalReqInfoField);

   939 		requestInfo.SetClientExternalId(KUnknownExternalReqInfoField);

   940 

   941 

   942 		// Process the privacy request.		

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

   944 		

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

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

   947 		}

   948 	

   949 	// All other location requests.

   950 	else

   951 		{

   952 		TPrivLocWaitLocationUpdateParams updateRequestParams(aSessionId,

   953 															aPosRequestMethod,

   954 															aSessionType,

   955 															aIsEmergency,

   956 															aQuality);

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

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

   959 		}

   960 	}

   961 

   962 // ----------------------------------------------------------------------------- 

   963 // CLbsPrivLocStateBase::OnSessionComplete

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

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

   966 // ----------------------------------------------------------------------------- 

   967 //

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

   969 																TInt aReason)

   970 	{

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

   972 		{

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

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

   975 		}		

   976 	}

   977 

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

   979 */

   980 void CLbsPrivLocStateBase::OnNetLocReferenceUpdate(

   981 		const TLbsNetSessionIdInt& /*aSessionId*/ , 

   982 		const TPositionInfoBase& aPosInfo)

   983 	{

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

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

   986 

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

   988 											   (sessionType == MLbsNetworkProtocolObserver::EServiceMobileTerminated)))

   989 		{

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

   991 		

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

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

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

   995 		// managers within LBS.

   996 		posInfo.SetModuleId(KLbsGpsLocManagerUid);

   997 		posInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   998 		posInfo.SetPositionModeReason(EPositionModeReasonNone);

   999 		posInfo.SetUpdateType(EPositionUpdateGeneral);

  1000 		

  1001 		if (!iFsm->RefPosProcessed())

  1002 			{

  1003 			iFsm->RefPosProcessed() = ETrue;

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

  1005 			}

  1006 

  1007 		}	

  1008 	}

  1009 

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

  1011 

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

  1013 implement its own version.

  1014 */

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

  1016 	{

  1017 	}

  1018 

  1019 

  1020 // ----------------------------------------------------------------------------- 

  1021 // CLbsPrivLocStateBase::ReadNetworkInducedAdminSetting

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

  1023 // ----------------------------------------------------------------------------- 

  1024 //

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

  1026 	{

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

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

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

  1030 	if (err == KErrNone)

  1031 		{

  1032 		switch (netRegStatus)

  1033 			{

  1034 			case RLbsNetworkRegistrationStatus::ERegisteredHomeNetwork:

  1035 				{

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

  1037 				break;

  1038 				}

  1039 			case RLbsNetworkRegistrationStatus::ERegisteredRoamingNetwork:

  1040 			case RLbsNetworkRegistrationStatus::ENotRegistered:

  1041 				{

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

  1043 				break;

  1044 				}		

  1045 			case RLbsNetworkRegistrationStatus::ENetworkRegistrationUnknown:

  1046 			default:

  1047 				{

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

  1049 							 netRegStatus);

  1050 				serviceStatus = CLbsAdmin::EExternalLocateOff;

  1051 				break;

  1052 				}

  1053 			}

  1054 		}

  1055 	else

  1056 		{

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

  1058 					 err);		

  1059 		}

  1060 	

  1061 	aExternalLocateService = serviceStatus;

  1062 	}

  1063 

  1064 // ----------------------------------------------------------------------------- 

  1065 // CLbsPrivLocStateBase::CLbsPrivLocStateBase

  1066 // Description: Constructor

  1067 // ----------------------------------------------------------------------------- 

  1068 //

  1069 CLbsPrivLocStateBase::CLbsPrivLocStateBase(CLbsPrivLocFsm* aFsm)

  1070 :	iFsm(aFsm)

  1071 	{	

  1072 	}

  1073 // ----------------------------------------------------------------------------- 

  1074 // CLbsPrivLocStateBase::PrivacyHandler, MessageSwitch, LbsAdmin

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

  1076 // the FSM

  1077 // Returns: pointers.

  1078 // ----------------------------------------------------------------------------- 

  1079 //

  1080 CPrivacyHandler* CLbsPrivLocStateBase::PrivacyHandler()

  1081 	{

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

  1083 	}

  1084 CNGMessageSwitch* CLbsPrivLocStateBase::MessageSwitch()

  1085 	{

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

  1087 	}

  1088 CLbsAdmin* CLbsPrivLocStateBase::LbsAdmin()

  1089 	{

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

  1091 	}

  1092 CAgpsInterfaceHandler* CLbsPrivLocStateBase::AgpsInterface()

  1093 	{

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

  1095 	}

  1096 

  1097 

  1098 TPositionModuleInfoExtended::TDeviceGpsModeCapabilities CLbsPrivLocStateBase::DeviceGpsModeCaps()

  1099 	{

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

  1101 	}

  1102 

  1103 CLbsAdmin::TLbsBehaviourMode CLbsPrivLocStateBase::BehaviourMode()

  1104 	{

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

  1106 	}

  1107 

  1108 RLbsNetworkRegistrationStatus& CLbsPrivLocStateBase::LbsNetworkRegistrationStatus()

  1109 	{

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

  1111 	}

  1112 

  1113 /*

  1114  * increments the network initiated positioning status count

  1115  * and remembers that it has done

  1116  */

  1117 void CLbsPrivLocStateBase::IncrementPositioningStatus()

  1118     {

  1119     iFsm->PrivLocHandler().IncrementPositioningStatus();

  1120     iFsm->WasPositioningStatusIncremented() = ETrue;

  1121     }

  1122 

  1123 

  1124 // ----------------------------------------------------------------------------- 

  1125 // 

  1126 // ----------------------- Class CLbsPrivLocIdleState --------------------

  1127 //

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

  1129 //

  1130 // ----------------------------------------------------------------------------- 

  1131 //

  1132 

  1133 // ----------------------------------------------------------------------------- 

  1134 // CLbsPrivLocIdleState::NewL