1 /**

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 /**

    21  @file argutils.h

    22 */

    23 

    24 #ifndef __ARG_UTILS_H__

    25 #define __ARG_UTILS_H__

    26 

    27 // LBS includes.

    28 #include <lbs.h>

    29 #include <lbscommon.h>

    30 #include <lbs/lbsprivacycontroller.h>

    31 #include <lbs/lbsnetcommon.h>

    32 //-------------------------------------------------------------------------------------------------

    33 

    34 /**

    35 Static utility functions to populate and instantiate arguments for function calls

    36 

    37 @internalComponent

    38 @test

    39 */

    40 

    41 const TInt KAlpha2Timeout = 12*1000*1000;

    42 const TInt KTTimeout = 8*1000*1000;

    43 const TInt KMOLRFixTime = 240*1000*1000;

    44 const TInt KMinHorizontalAcc = 50.0;

    45 const TInt KMinVerticalAcc = 1000.0;

    46 const TInt KDefaultMaxFixTime = 130*1000*1000;

    47 

    48 

    49 class ArgUtils

    50 	{

    51 public:

    52 	inline static void PopulateLC(RLbsAssistanceDataBuilderSet& aData)

    53 		{

    54 		aData.OpenL();

    55 		CleanupClosePushL(aData);

    56 		

    57 		// Access the Gps Reference Time which is the only data we support in this simple provider.

    58 		RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;

    59 

    60 		aData.GetDataBuilder(refTimeBuilder);

    61 		if (refTimeBuilder)

    62 			{

    63 			const TUint KAssistanceData_RefTime_Week = 12;

    64 			const TUint KAssistanceData_RefTime_Tow1MSec = 567;

    65 			// Fill out the reference time items we support - note the builder set is already open.

    66 			refTimeBuilder->SetField(TUEPositioningGpsReferenceTime::EGpsWeek, KAssistanceData_RefTime_Week);

    67 			refTimeBuilder->SetField(TUEPositioningGpsReferenceTime::EGpsTow1Msec, KAssistanceData_RefTime_Tow1MSec);

    68 

    69 			// Time stamp the data.

    70 			TTime timeStamp;

    71 			timeStamp.UniversalTime();

    72 

    73 			refTimeBuilder->SetTimeStamp(timeStamp);

    74 			}

    75 		}

    76 

    77 	inline static TLbsNetPosRequestPrivacy Privacy()

    78 		{

    79 		TLbsNetPosRequestPrivacy privacy;

    80 		privacy.SetRequestAdvice(TLbsNetPosRequestPrivacy::ERequestAdviceNotify);

    81 		privacy.SetRequestAction(TLbsNetPosRequestPrivacy::ERequestActionAllow);

    82 		return privacy;

    83 		}

    84 

    85 	inline static TLbsExternalRequestInfo RequestInfo()

    86 		{

    87 		TLbsExternalRequestInfo requestInfo;

    88 		requestInfo.SetRequesterId(_L8("+441234567891"));

    89 		requestInfo.SetClientName(_L8("THybridNWClient"));

    90 		requestInfo.SetClientExternalId(_L8("+441234567891"));	

    91 		return requestInfo;

    92 		}

    93 

    94 	inline static TPositionInfo PositionInfo()

    95 		{

    96 		TCoordinate coordinate(3.14159265359, 2.71828183);

    97 		TLocality locality(coordinate, 99.99, 99.99);

    98 		TTime time(101010101);

    99 		TPosition position(locality, time);

   100 		TPositionInfo positionInfo;

   101 		positionInfo.SetPosition(position);

   102 		return positionInfo;

   103 		}

   104 

   105 	inline static TPositionInfo ReferencePositionInfo()

   106 		{

   107 		// General case: This will be less accurate than the GPS Position and the Hybrid Position.

   108 		TCoordinate coordinate(51.5,-0.096, 2.0);

   109 		TLocality locality(coordinate, 1000.0, 1000.0);

   110 

   111 		// Setting time to current time

   112 		TTime time;

   113 		time.UniversalTime();

   114 		TPosition position(locality, time);

   115 

   116 		TPositionInfo positionInfo;

   117 		positionInfo.SetPosition(position);

   118 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   119 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   120 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   121 		return positionInfo;

   122 		}

   123 

   124 

   125 	inline static TPositionInfo MolrReferencePositionInfo()

   126 		{

   127 		// General case: This will be less accurate than the Reference Position and the Hybrid Position.

   128 		TCoordinate coordinate(3.14159265359, 2.71828183, 10.0);

   129 		TLocality locality(coordinate, 1000.0, 1000.0);

   130 

   131 		// Setting time to current time

   132 		TTime time;

   133 		time.UniversalTime();

   134 		TPosition position(locality, time);

   135 

   136 		TPositionInfo positionInfo;

   137 		positionInfo.SetPosition(position);

   138 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   139 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   140 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   141 		return positionInfo;

   142 		}

   143 

   144 

   145 	inline static TPositionInfo HybridPositionInfo()

   146 		{

   147 		// General case: This will be more accurate than ReferencePosition

   148 		// but less accurate than the GPS position

   149 		TCoordinate coordinate(51.502,-0.1055, 1.0);

   150 		TLocality locality(coordinate, 200.0, 200.0);

   151 

   152 		// Setting time to current time

   153 		TTime time;

   154 		time.UniversalTime();

   155 		TPosition position(locality, time);

   156 

   157 		TPositionInfo positionInfo;

   158 		positionInfo.SetPosition(position);

   159 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   160 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   161 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   162 		return positionInfo;

   163 		}

   164 

   165 

   166 	inline static TPositionInfo MolrHybridPositionInfo()

   167 		{

   168 		// General case: This will be more accurate than ReferencePosition

   169 		// but less accurate than the GPS position

   170 		TCoordinate coordinate(3.14159265359, 2.71828183);

   171 		TLocality locality(coordinate, 200.0, 200.0);

   172 

   173 		// Setting time to current time

   174 		TTime time;

   175 		time.UniversalTime();

   176 		TPosition position(locality, time);

   177 

   178 		TPositionInfo positionInfo;

   179 		positionInfo.SetPosition(position);

   180 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   181 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   182 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   183 		return positionInfo;

   184 		}

   185 

   186 

   187 	inline static TPositionInfo NetworkPositionInfo()

   188 		{

   189 		// General case: This will be more accurate than ReferencePosition

   190 		// but less accurate than the GPS position

   191 		TCoordinate coordinate(51.502,-0.1055, 1.0);

   192 		TLocality locality(coordinate, 100.0, 100.0);

   193 

   194 		// Setting time to current time

   195 		TTime time;

   196 		time.UniversalTime();

   197 		TPosition position(locality, time);

   198 

   199 		TPositionInfo positionInfo;

   200 		positionInfo.SetPosition(position);

   201 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   202 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   203 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   204 		return positionInfo;

   205 		}

   206 		

   207 	inline static TPositionInfo AccurateNetworkPositionInfo()

   208 		{

   209 		// General case: This will be more accurate than ReferencePosition

   210 		// but less accurate than the GPS position

   211 		TCoordinate coordinate(51.502,-0.1055, 1.0);

   212 		TLocality locality(coordinate, 10.0, 10.0);

   213 

   214 		// Setting time to current time

   215 		TTime time;

   216 		time.UniversalTime();

   217 		TPosition position(locality, time);

   218 

   219 		TPositionInfo positionInfo;

   220 		positionInfo.SetPosition(position);

   221 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   222 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   223 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   224 		return positionInfo;

   225 		}

   226 		

   227 	inline static TPositionInfo MolrNetworkPositionInfo()

   228 		{

   229 		// General case: This will be more accurate than ReferencePosition

   230 		// but less accurate than the GPS position

   231 		TCoordinate coordinate(3.14159265359, 2.71828183);

   232 		TLocality locality(coordinate, 100.0, 100.0);

   233 

   234 		// Setting time to current time

   235 		TTime time;

   236 		time.UniversalTime();

   237 		TPosition position(locality, time);

   238 

   239 		TPositionInfo positionInfo;

   240 		positionInfo.SetPosition(position);

   241 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   242 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   243 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   244 		return positionInfo;

   245 		}

   246 

   247 

   248 	inline static TLbsNetPosRequestQuality Quality()

   249 		{

   250 		TLbsNetPosRequestQuality quality;

   251 		quality.SetMaxFixTime(KTTimeout);

   252 		quality.SetMaxFixAge(0);

   253 		TRealX nan;

   254 		nan.SetNaN();

   255 		quality.SetMinHorizontalAccuracy(nan);

   256 		quality.SetMinVerticalAccuracy(nan);

   257 		return quality;

   258 		}

   259 

   260 	inline static TLbsNetPosRequestQuality QualityAlpha2()

   261 		{

   262 		TLbsNetPosRequestQuality quality;

   263 		quality.SetMaxFixTime(KAlpha2Timeout); 

   264 		quality.SetMaxFixAge(0);

   265 		TRealX nan;

   266 		nan.SetNaN();

   267 		quality.SetMinHorizontalAccuracy(nan);

   268 		quality.SetMinVerticalAccuracy(nan);

   269 		return quality;

   270 		}

   271 

   272 	inline static TLbsNetPosRequestMethod RequestMethod()

   273 		{

   274 		TLbsNetPosRequestMethod method;

   275 		TLbsNetPosMethod method1;

   276 		TLbsNetPosMethod method2;

   277 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted); 

   278 		const TLbsNetPosMethod posMethods [] =

   279 			{

   280 			method1,method2

   281 			};

   282 		method.SetPosMethods(posMethods, 2);

   283 		return method;

   284 		}

   285 

   286 	inline static TLbsNetPosRequestMethod RequestTerminalBasedMethod()

   287 		{

   288 		TLbsNetPosRequestMethod method;

   289 		TLbsNetPosMethod method1;

   290 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted);

   291 

   292  		const TLbsNetPosMethod posMethods [] =

   293 			{

   294 			method1

   295 			};

   296 		method.SetPosMethods(posMethods, 1);

   297 		return method;

   298 		}

   299 	

   300 	inline static TLbsNetPosRequestMethod RequestAutonomousMethod()

   301 		{

   302 		TLbsNetPosRequestMethod method;

   303 		TLbsNetPosMethod method1;

   304 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal);

   305 

   306  		const TLbsNetPosMethod posMethods [] =

   307 			{

   308 			method1

   309 			};

   310 		method.SetPosMethods(posMethods, 1);

   311 		return method;

   312 		}

   313 			

   314 	inline static TLbsNetPosRequestMethod RequestHybridMethod()

   315 		{

   316 		TLbsNetPosRequestMethod method;

   317 		TLbsNetPosMethod method1;

   318 		TLbsNetPosMethod method2;

   319 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted);

   320 		method2.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   321 

   322  		const TLbsNetPosMethod posMethods [] =

   323 			{

   324 			method1,method2

   325 			};

   326 		method.SetPosMethods(posMethods, 2);

   327 		return method;

   328 		}

   329 	

   330 			

   331 	inline static TLbsNetPosRequestMethod RequestTAPMethod()

   332 		{

   333 		TLbsNetPosRequestMethod method;

   334 		TLbsNetPosMethod method1;

   335 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   336 

   337  		const TLbsNetPosMethod posMethods [] =

   338 			{

   339 			method1

   340 			};

   341 		method.SetPosMethods(posMethods, 1);

   342 		return method;

   343 		}

   344 

   345 	inline static TLbsNetPosRequestMethod RequestTerminalAssistedAndTerminalBasedMethod()

   346 		{

   347 		TLbsNetPosRequestMethod method;

   348 		TLbsNetPosMethod method1;

   349 		TLbsNetPosMethod method2;

   350 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);

   351 		method2.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted);

   352 

   353  		const TLbsNetPosMethod posMethods [] =

   354 			{

   355 			method1,method2

   356 			};

   357 		method.SetPosMethods(posMethods, 2);

   358 		return method;

   359 		}

   360 	

   361 	inline static TLbsNetPosRequestMethod RequestUnspecifiedMethod()

   362 		{

   363 		TLbsNetPosRequestMethod method;

   364 		TLbsNetPosMethod method1;

   365 		method1.SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyUnknown);

   366 

   367  		const TLbsNetPosMethod posMethods [] =

   368 			{

   369 			method1

   370 			};

   371 		method.SetPosMethods(posMethods, 1);

   372 		return method;

   373 		}	

   374 

   375 	inline static TInt Alpha2()

   376 		{

   377 		return KAlpha2Timeout;

   378 		}

   379 

   380 	inline static TBool CompareQuality(TLbsNetPosRequestOptionsAssistance* aOpts, 

   381 										TBool aIsclientConnected, 

   382 										TInt aHorizontalAccuracy, 

   383 										TInt aVerticalAccuracy, 

   384 										TInt aMaxFixTime, 

   385 										TInt aMaxFixAge, 

   386 										TLbsAssistanceDataItem aDataMask, 

   387 										TPositionModuleInfo::TTechnologyType aTechnologyType

   388 										)

   389 		{

   390 		TLbsNetPosRequestQuality quality;

   391 		aOpts->GetRequestQuality(quality);

   392 		

   393 		if(aIsclientConnected != aOpts->NewClientConnected())

   394 			{

   395 			return EFalse;

   396 			}

   397 		

   398 		if(quality.MinHorizontalAccuracy() != aHorizontalAccuracy)	 

   399 			{

   400 			return EFalse;

   401 			}

   402 			

   403 		if(quality.MinVerticalAccuracy()   != aVerticalAccuracy)

   404 			{

   405 			return EFalse;

   406 			}

   407 			

   408 		if(quality.MaxFixTime() != aMaxFixTime)

   409 			{

   410 			return EFalse;

   411 			}

   412 			

   413 		if(quality.MaxFixAge()  != aMaxFixAge)		

   414 			{

   415 			return EFalse;

   416 			}

   417 			

   418 		if(aOpts->DataRequestMask()  != aDataMask) 

   419 			{

   420 			return EFalse;

   421 			}

   422 		

   423 		if(aOpts->PosMode() != aTechnologyType)

   424 			{

   425 			return EFalse;

   426 			}

   427 			

   428 		return ETrue;

   429 		}

   430 		

   431 		

   432 	inline static TBool ComparePositionInfoToReference(const TPositionInfo aPosInfoA)

   433 		{

   434 		TPositionInfo refPosInfo = ReferencePositionInfo();

   435 	

   436 		TPosition posA;

   437 		TPosition posR;

   438 		aPosInfoA.GetPosition(posA);

   439 		refPosInfo.GetPosition(posR);

   440 		

   441 		if(posA.HorizontalAccuracy() != posR.HorizontalAccuracy())

   442 			{

   443 			return EFalse;	

   444 			}

   445 		

   446 		if(posA.VerticalAccuracy() != posR.VerticalAccuracy())

   447 			{

   448 			return EFalse;	

   449 			}

   450 

   451 		if(posA.Latitude() != posR.Latitude())

   452 			{

   453 			return EFalse;	

   454 			}

   455 

   456 		if(posA.Longitude() != posR.Longitude())

   457 			{

   458 			return EFalse;	

   459 			}

   460 

   461 		if(posA.Altitude() != posR.Altitude())

   462 			{

   463 			return EFalse;	

   464 			}

   465 

   466 		return ETrue;

   467 		}

   468 

   469 

   470 	

   471 	inline static TBool ComparePositionInfoToMolrRefPos(const TPositionInfo aPosInfoA)

   472 		{

   473 		TPositionInfo refPosInfo = MolrReferencePositionInfo();

   474 	

   475 		TPosition posA;

   476 		TPosition posR;

   477 		aPosInfoA.GetPosition(posA);

   478 		refPosInfo.GetPosition(posR);

   479 		

   480 		if(posA.HorizontalAccuracy() != posR.HorizontalAccuracy())

   481 			{

   482 			return EFalse;	

   483 			}

   484 		

   485 		if(posA.VerticalAccuracy() != posR.VerticalAccuracy())

   486 			{

   487 			return EFalse;	

   488 			}

   489 

   490 		if(posA.Latitude() != posR.Latitude())

   491 			{

   492 			return EFalse;	

   493 			}

   494 

   495 		if(posA.Longitude() != posR.Longitude())

   496 			{

   497 			return EFalse;	

   498 			}

   499 

   500 		if(posA.Altitude() != posR.Altitude())

   501 			{

   502 			return EFalse;	

   503 			}

   504 

   505 		return ETrue;

   506 		}

   507 		

   508 	inline static TBool ComparePositionInfoToNan(const TPositionInfo aPosInfoA)

   509 		{

   510 		TPosition pos;

   511 		aPosInfoA.GetPosition(pos);

   512 		

   513 		if(!Math::IsNaN(pos.HorizontalAccuracy()))

   514 			{

   515 			return EFalse;

   516 			}

   517 

   518 		if(!Math::IsNaN(pos.VerticalAccuracy()))

   519 			{

   520 			return EFalse;

   521 			}

   522 			

   523 		if(!Math::IsNaN(pos.Latitude()))

   524 			{

   525 			return EFalse;

   526 			}

   527 			

   528 		if(!Math::IsNaN(pos.Longitude()))

   529 			{

   530 			return EFalse;

   531 			}

   532 			

   533 		if(!Math::IsNaN(pos.Altitude()))	

   534 			{

   535 			return EFalse;

   536 			}

   537 			

   538 		return ETrue;

   539 			

   540 		}

   541 		

   542 	};

   543 

   544 //-------------------------------------------------------------------------------------------------

   545 

   546 #endif //__ARG_UTILS_H__

   547