1 // Copyright (c) 2008-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 <s32mem.h>

    17 #include "lbsnetsim.h"

    18 #include "lbsnetsimgateway.h"

    19 #include "lbsnetsimgatewayobserver.h"

    20 #include "lbsnetsimtest.h"

    21 #include "lbsdevloggermacros.h"

    22 

    23 /**

    24 */

    25 EXPORT_C RLbsNetSim::RLbsNetSim() :

    26 	iRegisterLcsMoLrData(NULL), 

    27 	iReleaseLcsMoLrReasonPkg(iReleaseLcsMoLrReason),

    28 	iRequestMoreAssistanceDataFilterPkg(iRequestMoreAssistanceDataFilter),

    29 	iReleaseLcsLocationNotificationResponsePkg(iReleaseLcsLocationNotificationResponse),

    30 	iMeasurementReportLocation(NULL), iNotificationMeasurementControlLocation(NULL), 

    31 	iNotificationRegisterLcsLocation(NULL), iNotificationCancelPrivacyRequest(NULL), 

    32 	iNotificationResetAssistanceData(NULL)

    33 	{

    34 	}

    35 	

    36 	

    37 /**

    38 */

    39 EXPORT_C RLbsNetSim::~RLbsNetSim()

    40 	{

    41 	delete iRegisterLcsMoLrData;

    42 	}

    43 

    44 

    45 /**

    46 */

    47 EXPORT_C TInt RLbsNetSim::ConnectL(MLbsNetSimObserver* aObserver)

    48 	{

    49 	TInt err = KErrNone;

    50 

    51 	// Attempt to start the server and create a session

    52 	for (TInt x = 0; ((x < 2) && (err == KErrNone)); x++)

    53 		{

    54 		err = CreateSession(KLbsNetSimServerName, TVersion(0,0,0));

    55 		if (err == KErrNone)

    56 			{

    57 			break; // We have a session

    58 			}

    59 		

    60 		// Cant create a session

    61 		if ((err == KErrNotFound) || (err == KErrServerTerminated))

    62 			{

    63 			// We need to start the server

    64 			err = StartServer();

    65 			} // if

    66 		} // for

    67 		

    68 	// Leave if we have no session

    69 	if (err == KErrNone)

    70 		{

    71 		// Initialise the session to the correct type.

    72 		TIpcArgs args(EGatewayHandler);

    73 		err = SendReceive(EInitialise, args);

    74 		if (err == KErrNone)

    75 			{

    76 			iObserver = aObserver;

    77 			

    78 			// Create message handlers

    79 			iMeasurementReportLocation = new (ELeave) CMeasurementReportLocation(this, iObserver);

    80 			

    81 			// Create notifications

    82 			iNotificationMeasurementControlLocation = CNotificationMeasurementControlLocation::NewL(this, iObserver);

    83 			iNotificationRegisterLcsLocation = new (ELeave) CNotificationRegisterLcsLocation(this, iObserver);

    84 			iNotificationCancelPrivacyRequest = new (ELeave) CNotificationCancelPrivacyRequest(this, iObserver);

    85 			iNotificationNetworkGone = new (ELeave) CNotificationNetworkGone(this, iObserver);

    86 			iNotificationResetAssistanceData = new (ELeave) CNotificationResetAssistanceData(this, iObserver);

    87 			}

    88 		}

    89 		

    90 	return err;		

    91 	}

    92 

    93 

    94 /**

    95 */

    96 EXPORT_C void RLbsNetSim::Close()

    97 	{

    98 	// Cleanup here as they are created in Connect

    99 	delete iMeasurementReportLocation;

   100 	delete iNotificationMeasurementControlLocation;

   101 	delete iNotificationRegisterLcsLocation;

   102 	delete iNotificationCancelPrivacyRequest;

   103 	delete iNotificationNetworkGone;

   104 	delete iNotificationResetAssistanceData;

   105 	

   106 	RSessionBase::Close();

   107 	}

   108 

   109 

   110 /**

   111 */

   112 EXPORT_C void RLbsNetSim::RegisterLcsMoLrL(const TDesC& aData)

   113 	{

   114 	LBSLOG(ELogP1, "RLbsNetSim::RegisterLcsMoLrL()");

   115 	if (iRegisterLcsMoLrData != NULL)

   116 		{

   117 		delete iRegisterLcsMoLrData;

   118 		iRegisterLcsMoLrData = NULL;

   119 		}

   120 	

   121 	iRegisterLcsMoLrData = aData.Alloc();

   122 	TIpcArgs args(iRegisterLcsMoLrData);

   123 	

   124 	User::LeaveIfError(RSessionBase::Send(EGWRegisterLcsMoLr, args));

   125 	}

   126 

   127 

   128 /**

   129 */

   130 EXPORT_C void RLbsNetSim::ReleaseLcsMoLrL(TInt aReason)

   131 	{

   132 	LBSLOG(ELogP1, "RLbsNetSim::ReleaseLcsMoLrL()");

   133 	iReleaseLcsMoLrReason = aReason;

   134 	TIpcArgs args(&iReleaseLcsMoLrReasonPkg);

   135 	User::LeaveIfError(RSessionBase::Send(EGWReleaseLcsMoLr, args));

   136 	}

   137 

   138 

   139 /**

   140 */

   141 EXPORT_C void RLbsNetSim::ReleaseLcsLocationNotificationL(const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResponse)

   142 	{

   143 	LBSLOG(ELogP1, "RLbsNetSim::ReleaseLcsLocationNotificationL()");

   144 	iReleaseLcsLocationNotificationResponse = aResponse;

   145 	TIpcArgs args(&iReleaseLcsLocationNotificationResponsePkg);

   146 	User::LeaveIfError(RSessionBase::Send(EGWReleaseLcsLocationNotification, args));

   147 	

   148 	}

   149 

   150 

   151 /**

   152 */

   153 EXPORT_C void RLbsNetSim::MeasurementReportLocationL(const TPositionInfoBase& aPosition)

   154 	{

   155 	LBSLOG(ELogP1, "RLbsNetSim::MeasurementReportLocationL()");

   156 	iMeasurementReportLocation->SendL(reinterpret_cast<const TPositionInfo&>(aPosition));

   157 	}

   158 

   159 

   160 /**

   161 */

   162 EXPORT_C void RLbsNetSim::MeasurementReportLocationRequestMoreAssistanceDataL(const TLbsAssistanceDataGroup& aFilter)

   163 	{

   164 	LBSLOG(ELogP1, "RLbsNetSim::MeasurementReportLocationRequestMoreAssistanceDataL()");

   165 	iRequestMoreAssistanceDataFilter = aFilter;

   166 	TIpcArgs args(&iRequestMoreAssistanceDataFilterPkg);

   167 	User::LeaveIfError(RSessionBase::Send(EGWRequestMoreAssistanceData, args));

   168 	}

   169 

   170 

   171 /**

   172 */

   173 EXPORT_C void RLbsNetSim::MeasurementControlFailureL(TInt aReason)

   174 	{

   175 	LBSLOG(ELogP1, "RLbsNetSim::MeasurementControlFailureL()");

   176 	TIpcArgs args(aReason);

   177 	User::LeaveIfError(RSessionBase::Send(EGWMeasurementControlFailure, args));

   178 	}

   179 	

   180 

   181 //

   182 // Private methods

   183 

   184 /**

   185 */

   186 TInt RLbsNetSim::StartServer()

   187 	{

   188 	RProcess server;

   189 

   190  	// Create the process/server

   191  	TInt err = server.Create(KLBSNetSimServerBinary, KNullDesC);

   192 

   193  	if (err == KErrNone)

   194  		{

   195 		TRequestStatus status;

   196  	

   197  		// Start the server

   198  		server.Rendezvous(status);

   199  		if (status != KRequestPending)

   200  			{

   201  			server.Kill(KErrNone);

   202  			} // if

   203  		else

   204  			{

   205  			server.Resume();

   206  			} // else

   207  			

   208 	 	// Wait for server to start

   209 	 	User::WaitForRequest(status);

   210 	 		

   211 	 	// Result

   212 	 	err = (server.ExitType() == EExitPanic) ? KErrGeneral : status.Int();

   213  			

   214 	 	// Cleanup

   215 	 	server.Close();

   216  		} // if

   217  		

   218  	return err;

   219 	}

   220 

   221 	

   222 //

   223 // Callback Handler: CNotificationMeasurementControlLocation

   224 RLbsNetSim::CNotificationMeasurementControlLocation* RLbsNetSim::CNotificationMeasurementControlLocation::NewL(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver)

   225 	{

   226 	CNotificationMeasurementControlLocation* self = new(ELeave) CNotificationMeasurementControlLocation(aNetSim, aObserver);

   227 	CleanupStack::PushL(self);

   228 	self->ConstructL();

   229 	CleanupStack::Pop();

   230 	

   231 	return self;

   232 	}

   233 	

   234 void RLbsNetSim::CNotificationMeasurementControlLocation::ConstructL()

   235 	{

   236 	TInt size = RLbsAssistanceDataBuilderSet::MaxExternalizedBufferSize();

   237 	iAssistanceDataBuffer = HBufC8::NewL(size);

   238 	iPtr.Set(iAssistanceDataBuffer->Des());

   239 	

   240 	TIpcArgs args(&iPositionPkg, &iQualityPkg, &iPtr);

   241 	iNetSim->SendReceive(EGWNotificationMeasurementControlLocation, args, iStatus);

   242 	SetActive();

   243 	}

   244 

   245 RLbsNetSim::CNotificationMeasurementControlLocation::CNotificationMeasurementControlLocation(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver) :

   246 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver),

   247 	iPositionPkg(iPosition), iQualityPkg(iQuality), iAssistanceDataBuffer(NULL), iPtr(NULL, 0)

   248 	{

   249 	CActiveScheduler::Add(this);

   250 	}

   251 	

   252 RLbsNetSim::CNotificationMeasurementControlLocation::~CNotificationMeasurementControlLocation()

   253 	{

   254 	Cancel();

   255 

   256 	delete iAssistanceDataBuffer;

   257 	}

   258 	

   259 	

   260 void RLbsNetSim::CNotificationMeasurementControlLocation::RunL()

   261 	{

   262 	LBSLOG(ELogP1, "RLbsNetSim::CNotificationMeasurementControlLocation::RunL()");

   263 	if (iStatus == KErrNone)

   264 		{

   265 		// Read the assistance data

   266 		RLbsAssistanceDataBuilderSet assistanceData;

   267 		assistanceData.OpenL();

   268 		CleanupClosePushL(assistanceData);

   269 		RDesReadStream read(iPtr);

   270 		CleanupClosePushL(read);

   271 		assistanceData.InternalizeL(read);

   272 		

   273 		LBSLOG(ELogP2, "Calling iObserver->ProcessMeasurementControlLocation()");

   274 		// A reference location must bo of "Network" type.

   275 		iPosition.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   276 		iObserver->ProcessMeasurementControlLocation(iPositionPkg(), assistanceData, iQualityPkg());

   277 		

   278 		CleanupStack::PopAndDestroy(2);

   279 		}

   280 	else

   281 		{

   282 		if (iStatus.Int() == RLbsNetSimTest::KNetSimNetworkNotAvailable)

   283 			{

   284 			LBSLOG(ELogP2, "Calling iObserver->ProcessError(KErrNotReady)");

   285 			iObserver->ProcessError(KErrNotReady);

   286 			}

   287 		else

   288 			{

   289 			LBSLOG2(ELogP2, "Calling iObserver->ProcessMeasurementControlLocationError(%d)", iStatus.Int());

   290 			iObserver->ProcessMeasurementControlLocationError(iStatus.Int());

   291 			}

   292 		}

   293 		

   294 	// Restart

   295 	TIpcArgs args(&iPositionPkg, &iQualityPkg, &iPtr);

   296 	iNetSim->SendReceive(EGWNotificationMeasurementControlLocation, args, iStatus);

   297 	SetActive();

   298 	}

   299 

   300 void RLbsNetSim::CNotificationMeasurementControlLocation::DoCancel()

   301 	{

   302 	iNetSim->Send(EGWNotificationMeasurementControlLocationCancel);

   303 	}

   304 	

   305 //

   306 // Callback Handler: CMeasurementReportLocation

   307 RLbsNetSim::CMeasurementReportLocation::CMeasurementReportLocation(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver) :

   308 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver), 

   309 	iReasonPkg(iReason), iPositionPkg(iPosition), iFireNotificationPkg(iFireNotification)

   310 	{

   311 	CActiveScheduler::Add(this);

   312 	}

   313 

   314 RLbsNetSim::CMeasurementReportLocation::~CMeasurementReportLocation()

   315 	{

   316 	Cancel();

   317 	}

   318 	

   319 void RLbsNetSim::CMeasurementReportLocation::SendL(const TPositionInfo& aPosition)

   320 	{

   321 	if (!IsActive())

   322 		{

   323 		iPosition = aPosition;

   324 		

   325 		// Setup argument for data

   326 		TIpcArgs args(&iReasonPkg, &iPositionPkg, &iFireNotificationPkg);

   327 		iNetSim->SendReceive(EGWMeasurementReportLocation, args, iStatus);

   328 		SetActive();

   329 		}

   330 	else

   331 		{

   332 		User::Leave(KErrInUse);

   333 		}

   334 		

   335 	}

   336 	

   337 void RLbsNetSim::CMeasurementReportLocation::RunL()

   338 	{

   339 	LBSLOG(ELogP1, "RLbsNetSim::CMeasurementReportLocation::RunL()");

   340 	if (iStatus == KErrNone)

   341 		{

   342 		if (iFireNotification) // This will only be true under MoLr

   343 			{

   344 			LBSLOG2(ELogP2, "Calling iObserver->ProcessFacilityLcsMoLrResult(%d, <TPositionInfo>)", iReason);

   345 			// A final network location must be of "Assisted" type.

   346 			// Even if no assistance data has been used when calculating the location.

   347 			// It is because we use the technology type to distinguish between

   348 			// the reference and the final location updates.

   349 			iPosition.SetPositionMode(iPosition.PositionMode() | TPositionModuleInfo::ETechnologyAssisted);

   350 			iObserver->ProcessFacilityLcsMoLrResult(iReason, &iPosition);

   351 			} // if

   352 		}

   353 	else

   354 		{

   355 		if (iStatus.Int() == RLbsNetSimTest::KNetSimNetworkNotAvailable)

   356 			{

   357 			LBSLOG(ELogP2, "Calling iObserver->ProcessError(KErrNotReady)");

   358 			iObserver->ProcessError(KErrNotReady);

   359 			}

   360 		else

   361 			{

   362 			if (iFireNotification)

   363 				{

   364 				LBSLOG2(ELogP2, "Calling iObserver->ProcessFacilityLcsMoLrResult(%d, NULL)", iStatus.Int());

   365 				iObserver->ProcessFacilityLcsMoLrResult(iStatus.Int(), NULL);

   366 				}

   367 			}

   368 		}

   369 	}

   370 

   371 void RLbsNetSim::CMeasurementReportLocation::DoCancel()

   372 	{

   373 	iNetSim->Send(EGWMeasurementReportLocationCancel);

   374 	}

   375 

   376 //

   377 // Callback Handler: CNotificationRegisterLcsLocation

   378 RLbsNetSim::CNotificationRegisterLcsLocation::CNotificationRegisterLcsLocation(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver) :

   379 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver),

   380 	iRequestInfoPkg(iRequestInfo), iRequestPrivacyPkg(iRequestPrivacy)

   381 	{

   382 	CActiveScheduler::Add(this);

   383 

   384 	TIpcArgs args(&iRequestInfoPkg, &iRequestPrivacyPkg);

   385 	iNetSim->SendReceive(EGWNotificationRegisterLcsLocation, args, iStatus);

   386 	SetActive();

   387 	}

   388 

   389 RLbsNetSim::CNotificationRegisterLcsLocation::~CNotificationRegisterLcsLocation()

   390 	{

   391 	Cancel();

   392 	}

   393 	

   394 	

   395 void RLbsNetSim::CNotificationRegisterLcsLocation::RunL()

   396 	{

   397 	LBSLOG(ELogP1, "RLbsNetSim::CNotificationRegisterLcsLocation::RunL()");

   398 	if (iStatus == KErrNone)

   399 		{

   400 		LBSLOG(ELogP2, "Calling iObserver->ProcessRegisterLcsLocationNotification(<RequestInfo>, <RequestPrivacy>)");

   401 		iObserver->ProcessRegisterLcsLocationNotification(iRequestInfo, iRequestPrivacy);

   402 		}

   403 	else

   404 		{

   405 		if (iStatus.Int() == RLbsNetSimTest::KNetSimNetworkNotAvailable)

   406 			{

   407 			LBSLOG(ELogP2, "Calling iObserver->ProcessError(KErrNotReady)");

   408 			iObserver->ProcessError(KErrNotReady);

   409 			}

   410 		else

   411 			{

   412 			LBSLOG2(ELogP2, "Calling iObserver->ProcessError(%d)", iStatus.Int());

   413 			iObserver->ProcessError(iStatus.Int());

   414 			}

   415 		}

   416 		

   417 	// Restart

   418 	TIpcArgs args(&iRequestInfoPkg, &iRequestPrivacyPkg);

   419 	iNetSim->SendReceive(EGWNotificationRegisterLcsLocation, args, iStatus);

   420 	SetActive();

   421 	}

   422 

   423 void RLbsNetSim::CNotificationRegisterLcsLocation::DoCancel()

   424 	{

   425 	iNetSim->Send(EGWNotificationRegisterLcsLocationCancel);

   426 	}

   427 

   428 //

   429 // Callback Handler: CNotificationCancelPrivacyRequest

   430 RLbsNetSim::CNotificationCancelPrivacyRequest::CNotificationCancelPrivacyRequest(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver) :

   431 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver), iReason(0), iReasonPkg(iReason)

   432 	{

   433 	CActiveScheduler::Add(this);

   434 

   435 	TIpcArgs args(&iReasonPkg);

   436 	iNetSim->SendReceive(EGWNotificationCancelPrivacy, args, iStatus);

   437 	SetActive();

   438 	}

   439 

   440 RLbsNetSim::CNotificationCancelPrivacyRequest::~CNotificationCancelPrivacyRequest()

   441 	{

   442 	Cancel();

   443 	}

   444 	

   445 	

   446 void RLbsNetSim::CNotificationCancelPrivacyRequest::RunL()

   447 	{

   448 	LBSLOG(ELogP1, "RLbsNetSim::CNotificationCancelPrivacyRequest::RunL()");

   449 	

   450 	LBSLOG2(ELogP2, "Calling iObserver->ProcessReleaseLcsLocationNotification(%d)", iReason);

   451 	iObserver->ProcessReleaseLcsLocationNotification(iReason);

   452 		

   453 	// Restart

   454 	TIpcArgs args(&iReasonPkg);

   455 	iNetSim->SendReceive(EGWNotificationCancelPrivacy, args, iStatus);

   456 	SetActive();

   457 	}

   458 

   459 void RLbsNetSim::CNotificationCancelPrivacyRequest::DoCancel()

   460 	{

   461 	iNetSim->Send(EGWNotificationCancelPrivacyCancel);

   462 	}

   463 

   464 //

   465 // Callback Handler: CNotificationNetworkGone

   466 RLbsNetSim::CNotificationNetworkGone::CNotificationNetworkGone(RLbsNetSim* aNetSim, MLbsNetSimObserver* aObserver) :

   467 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver)

   468 	{

   469 	CActiveScheduler::Add(this);

   470 

   471 	iNetSim->SendReceive(EGWNotificationNetworkGone, iStatus);

   472 	SetActive();

   473 	}

   474 

   475 RLbsNetSim::CNotificationNetworkGone::~CNotificationNetworkGone()

   476 	{

   477 	Cancel();

   478 	}

   479 	

   480 	

   481 void RLbsNetSim::CNotificationNetworkGone::RunL()

   482 	{

   483 	LBSLOG(ELogP1, "RLbsNetSim::CNotificationNetworkGone::RunL()");

   484 	if (iStatus != KErrCancel)

   485 		{

   486 		LBSLOG(ELogP2, "Calling iObserver->ProcessError(KErrNotReady)");

   487 		iObserver->ProcessError(KErrNotReady);

   488 		}

   489 		

   490 	// Restart

   491 	iNetSim->SendReceive(EGWNotificationNetworkGone, iStatus);

   492 	SetActive();

   493 	}

   494 

   495 void RLbsNetSim::CNotificationNetworkGone::DoCancel()

   496 	{

   497 	iNetSim->Send(EGWNotificationNetworkGoneCancel);

   498 	}

   499 

   500 //

   501 // Callback Handler: CNotificationResetAssistanceData

   502 RLbsNetSim::CNotificationResetAssistanceData::CNotificationResetAssistanceData(RLbsNetSim* aNetSim, 

   503 								MLbsNetSimObserver* aObserver) :

   504 	CActive(EPriorityStandard), iNetSim(aNetSim), iObserver(aObserver), iMask(0), iMaskPkg(iMask)

   505 	{

   506 	CActiveScheduler::Add(this);

   507 

   508 	// Restart

   509 	TIpcArgs args(&iMaskPkg);

   510 	iNetSim->SendReceive(EGWNotificationResetAssistanceData, args, iStatus);

   511 	SetActive();

   512 	}

   513 

   514 RLbsNetSim::CNotificationResetAssistanceData::~CNotificationResetAssistanceData()

   515 	{

   516 	Cancel();

   517 	}

   518 	

   519 	

   520 void RLbsNetSim::CNotificationResetAssistanceData::RunL()

   521 	{

   522 	LBSLOG(ELogP1, "RLbsNetSim::CNotificationResetAssistanceData::RunL()");

   523 	if (iStatus == KErrNone)

   524 		{

   525 		LBSLOG2(ELogP2, "Calling iObserver->ProcessResetAssistanceData(0x%x)", iMask);

   526 		iObserver->ProcessResetAssistanceData(iMask);

   527 		}

   528 	else

   529 		{

   530 		LBSLOG2(ELogP2, "Error reported when trying to send reset assistance data: %d", iStatus.Int());

   531 		}

   532 		

   533 	// Restart

   534 	TIpcArgs args(&iMaskPkg);

   535 	iNetSim->SendReceive(EGWNotificationResetAssistanceData, args, iStatus);

   536 	SetActive();

   537 	}

   538 

   539 void RLbsNetSim::CNotificationResetAssistanceData::DoCancel()

   540 	{

   541 	iNetSim->Send(EGWNotificationResetAssistanceDataCancel);

   542 	}