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 the License "Symbian Foundation License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 /**

    23  @file argutils.h

    24 */

    25 

    26 #ifndef __ARG_UTILS_H__

    27 #define __ARG_UTILS_H__

    28 

    29 // LBS includes.

    30 #include <lbs.h>

    31 #include <lbscommon.h>

    32 #include <lbsprivacycontroller.h>

    33 #include <lbsnetcommon.h>

    34 //-------------------------------------------------------------------------------------------------

    35 

    36 /**

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

    38 

    39 @internalComponent

    40 @test

    41 */

    42 

    43 const TInt KAlpha2Timeout = 12*1000*1000;

    44 const TInt KTTimeout = 8*1000*1000;

    45 const TInt KMOLRFixTime = 240*1000*1000;

    46 const TInt KMinHorizontalAcc = 50.0;

    47 const TInt KMinVerticalAcc = 1000.0;

    48 const TInt KDefaultMaxFixTime = 130*1000*1000;

    49 

    50 

    51 class ArgUtils

    52 	{

    53 public:

    54 	inline static void PopulateLC(RLbsAssistanceDataBuilderSet& aData)

    55 		{

    56 		aData.OpenL();

    57 		CleanupClosePushL(aData);

    58 		

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

    60 		RUEPositioningGpsReferenceTimeBuilder* refTimeBuilder = NULL;

    61 

    62 		aData.GetDataBuilder(refTimeBuilder);

    63 		if (refTimeBuilder)

    64 			{

    65 			const TUint KAssistanceData_RefTime_Week = 12;

    66 			const TUint KAssistanceData_RefTime_Tow1MSec = 567;

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

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

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

    70 

    71 			// Time stamp the data.

    72 			TTime timeStamp;

    73 			timeStamp.UniversalTime();

    74 

    75 			refTimeBuilder->SetTimeStamp(timeStamp);

    76 			}

    77 		}

    78 

    79 	inline static TLbsNetPosRequestPrivacy Privacy()

    80 		{

    81 		TLbsNetPosRequestPrivacy privacy;

    82 		privacy.SetRequestAdvice(TLbsNetPosRequestPrivacy::ERequestAdviceNotify);

    83 		privacy.SetRequestAction(TLbsNetPosRequestPrivacy::ERequestActionAllow);

    84 		return privacy;

    85 		}

    86 

    87 	inline static TLbsExternalRequestInfo RequestInfo()

    88 		{

    89 		TLbsExternalRequestInfo requestInfo;

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

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

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

    93 		return requestInfo;

    94 		}

    95 

    96 	inline static TPositionInfo PositionInfo()

    97 		{

    98 		TCoordinate coordinate(3.14159265359, 2.71828183);

    99 		TLocality locality(coordinate, 99.99, 99.99);

   100 		TTime time(101010101);

   101 		TPosition position(locality, time);

   102 		TPositionInfo positionInfo;

   103 		positionInfo.SetPosition(position);

   104 		return positionInfo;

   105 		}

   106 

   107 	inline static TPositionInfo ReferencePositionInfo()

   108 		{

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

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

   111 		TLocality locality(coordinate, 1000.0, 1000.0);

   112 

   113 		// Setting time to current time

   114 		TTime time;

   115 		time.UniversalTime();

   116 		TPosition position(locality, time);

   117 

   118 		TPositionInfo positionInfo;

   119 		positionInfo.SetPosition(position);

   120 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   121 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   122 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   123 		return positionInfo;

   124 		}

   125 

   126 

   127 	inline static TPositionInfo MolrReferencePositionInfo()

   128 		{

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

   130 		TCoordinate coordinate(3.14159265359, 2.71828183, 10.0);

   131 		TLocality locality(coordinate, 1000.0, 1000.0);

   132 

   133 		// Setting time to current time

   134 		TTime time;

   135 		time.UniversalTime();

   136 		TPosition position(locality, time);

   137 

   138 		TPositionInfo positionInfo;

   139 		positionInfo.SetPosition(position);

   140 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

   141 		positionInfo.SetPositionMode(TPositionModuleInfo::ETechnologyNetwork);

   142 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   143 		return positionInfo;

   144 		}

   145 

   146 

   147 	inline static TPositionInfo HybridPositionInfo()

   148 		{

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

   150 		// but less accurate than the GPS position

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

   152 		TLocality locality(coordinate, 200.0, 200.0);

   153 

   154 		// Setting time to current time

   155 		TTime time;

   156 		time.UniversalTime();

   157 		TPosition position(locality, time);

   158 

   159 		TPositionInfo positionInfo;

   160 		positionInfo.SetPosition(position);

   161 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

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

   163 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   164 		return positionInfo;

   165 		}

   166 

   167 

   168 	inline static TPositionInfo MolrHybridPositionInfo()

   169 		{

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

   171 		// but less accurate than the GPS position

   172 		TCoordinate coordinate(3.14159265359, 2.71828183);

   173 		TLocality locality(coordinate, 200.0, 200.0);

   174 

   175 		// Setting time to current time

   176 		TTime time;

   177 		time.UniversalTime();

   178 		TPosition position(locality, time);

   179 

   180 		TPositionInfo positionInfo;

   181 		positionInfo.SetPosition(position);

   182 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

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

   184 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   185 		return positionInfo;

   186 		}

   187 

   188 

   189 	inline static TPositionInfo NetworkPositionInfo()

   190 		{

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

   192 		// but less accurate than the GPS position

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

   194 		TLocality locality(coordinate, 100.0, 100.0);

   195 

   196 		// Setting time to current time

   197 		TTime time;

   198 		time.UniversalTime();

   199 		TPosition position(locality, time);

   200 

   201 		TPositionInfo positionInfo;

   202 		positionInfo.SetPosition(position);

   203 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

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

   205 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   206 		return positionInfo;

   207 		}

   208 		

   209 	inline static TPositionInfo AccurateNetworkPositionInfo()

   210 		{

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

   212 		// but less accurate than the GPS position

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

   214 		TLocality locality(coordinate, 10.0, 10.0);

   215 

   216 		// Setting time to current time

   217 		TTime time;

   218 		time.UniversalTime();

   219 		TPosition position(locality, time);

   220 

   221 		TPositionInfo positionInfo;

   222 		positionInfo.SetPosition(position);

   223 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

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

   225 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   226 		return positionInfo;

   227 		}

   228 		

   229 	inline static TPositionInfo MolrNetworkPositionInfo()

   230 		{

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

   232 		// but less accurate than the GPS position

   233 		TCoordinate coordinate(3.14159265359, 2.71828183);

   234 		TLocality locality(coordinate, 100.0, 100.0);

   235 

   236 		// Setting time to current time

   237 		TTime time;

   238 		time.UniversalTime();

   239 		TPosition position(locality, time);

   240 

   241 		TPositionInfo positionInfo;

   242 		positionInfo.SetPosition(position);

   243 		positionInfo.SetUpdateType(EPositionUpdateGeneral);

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

   245 		positionInfo.SetPositionModeReason(EPositionModeReasonNone);

   246 		return positionInfo;

   247 		}

   248 

   249 

   250 	inline static TLbsNetPosRequestQuality Quality()

   251 		{

   252 		TLbsNetPosRequestQuality quality;

   253 		quality.SetMaxFixTime(KTTimeout);

   254 		quality.SetMaxFixAge(0);

   255 		TRealX nan;

   256 		nan.SetNaN();

   257 		quality.SetMinHorizontalAccuracy(nan);

   258 		quality.SetMinVerticalAccuracy(nan);

   259 		return quality;

   260 		}

   261 

   262 	inline static TLbsNetPosRequestQuality QualityAlpha2()

   263 		{

   264 		TLbsNetPosRequestQuality quality;

   265 		quality.SetMaxFixTime(KAlpha2Timeout); 

   266 		quality.SetMaxFixAge(0);

   267 		TRealX nan;

   268 		nan.SetNaN();

   269 		quality.SetMinHorizontalAccuracy(nan);

   270 		quality.SetMinVerticalAccuracy(nan);

   271 		return quality;

   272 		}

   273 

   274 	inline static TLbsNetPosRequestMethod RequestMethod()

   275 		{

   276 		TLbsNetPosRequestMethod method;

   277 		TLbsNetPosMethod method1;

   278 		TLbsNetPosMethod method2;

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

   280 		const TLbsNetPosMethod posMethods [] =

   281 			{

   282 			method1,method2

   283 			};

   284 		method.SetPosMethods(posMethods, 2);

   285 		return method;

   286 		}

   287 

   288 	inline static TLbsNetPosRequestMethod RequestTerminalBasedMethod()

   289 		{

   290 		TLbsNetPosRequestMethod method;

   291 		TLbsNetPosMethod method1;

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

   293 

   294  		const TLbsNetPosMethod posMethods [] =

   295 			{

   296 			method1

   297 			};

   298 		method.SetPosMethods(posMethods, 1);

   299 		return method;

   300 		}

   301 	

   302 	inline static TLbsNetPosRequestMethod RequestAutonomousMethod()

   303 		{

   304 		TLbsNetPosRequestMethod method;

   305 		TLbsNetPosMethod method1;

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

   307 

   308  		const TLbsNetPosMethod posMethods [] =

   309 			{

   310 			method1

   311 			};

   312 		method.SetPosMethods(posMethods, 1);

   313 		return method;

   314 		}

   315 			

   316 	inline static TLbsNetPosRequestMethod RequestHybridMethod()

   317 		{

   318 		TLbsNetPosRequestMethod method;

   319 		TLbsNetPosMethod method1;

   320 		TLbsNetPosMethod method2;

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

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

   323 

   324  		const TLbsNetPosMethod posMethods [] =

   325 			{

   326 			method1,method2

   327 			};

   328 		method.SetPosMethods(posMethods, 2);

   329 		return method;

   330 		}

   331 	

   332 			

   333 	inline static TLbsNetPosRequestMethod RequestTAPMethod()

   334 		{

   335 		TLbsNetPosRequestMethod method;

   336 		TLbsNetPosMethod method1;

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

   338 

   339  		const TLbsNetPosMethod posMethods [] =

   340 			{

   341 			method1

   342 			};

   343 		method.SetPosMethods(posMethods, 1);

   344 		return method;

   345 		}

   346 

   347 	inline static TLbsNetPosRequestMethod RequestTerminalAssistedAndTerminalBasedMethod()

   348 		{

   349 		TLbsNetPosRequestMethod method;

   350 		TLbsNetPosMethod method1;

   351 		TLbsNetPosMethod method2;

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

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

   354 

   355  		const TLbsNetPosMethod posMethods [] =

   356 			{

   357 			method1,method2

   358 			};

   359 		method.SetPosMethods(posMethods, 2);

   360 		return method;

   361 		}

   362 	

   363 	inline static TLbsNetPosRequestMethod RequestUnspecifiedMethod()

   364 		{

   365 		TLbsNetPosRequestMethod method;

   366 		TLbsNetPosMethod method1;

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

   368 

   369  		const TLbsNetPosMethod posMethods [] =

   370 			{

   371 			method1

   372 			};

   373 		method.SetPosMethods(posMethods, 1);

   374 		return method;

   375 		}	

   376 

   377 	inline static TInt Alpha2()

   378 		{

   379 		return KAlpha2Timeout;

   380 		}

   381 

   382 	inline static TBool CompareQuality(TLbsNetPosRequestOptionsAssistance* aOpts, 

   383 										TBool aIsclientConnected, 

   384 										TInt aHorizontalAccuracy, 

   385 										TInt aVerticalAccuracy, 

   386 										TInt aMaxFixTime, 

   387 										TInt aMaxFixAge, 

   388 										TLbsAssistanceDataItem aDataMask, 

   389 										TPositionModuleInfo::TTechnologyType aTechnologyType

   390 										)

   391 		{

   392 		TLbsNetPosRequestQuality quality;

   393 		aOpts->GetRequestQuality(quality);

   394 		

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

   396 			{

   397 			return EFalse;

   398 			}

   399 		

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

   401 			{

   402 			return EFalse;

   403 			}

   404 			

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

   406 			{

   407 			return EFalse;

   408 			}

   409 			

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

   411 			{

   412 			return EFalse;

   413 			}

   414 			

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

   416 			{

   417 			return EFalse;

   418 			}

   419 			

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

   421 			{

   422 			return EFalse;

   423 			}

   424 		

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

   426 			{

   427 			return EFalse;

   428 			}

   429 			

   430 		return ETrue;

   431 		}

   432 		

   433 		

   434 	inline static TBool ComparePositionInfoToReference(const TPositionInfo aPosInfoA)

   435 		{

   436 		TPositionInfo refPosInfo = ReferencePositionInfo();

   437 	

   438 		TPosition posA;

   439 		TPosition posR;

   440 		aPosInfoA.GetPosition(posA);

   441 		refPosInfo.GetPosition(posR);

   442 		

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

   444 			{

   445 			return EFalse;	

   446 			}

   447 		

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

   449 			{

   450 			return EFalse;	

   451 			}

   452 

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

   454 			{

   455 			return EFalse;	

   456 			}

   457 

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

   459 			{

   460 			return EFalse;	

   461 			}

   462 

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

   464 			{

   465 			return EFalse;	

   466 			}

   467 

   468 		return ETrue;

   469 		}

   470 

   471 

   472 	

   473 	inline static TBool ComparePositionInfoToMolrRefPos(const TPositionInfo aPosInfoA)

   474 		{

   475 		TPositionInfo refPosInfo = MolrReferencePositionInfo();

   476 	

   477 		TPosition posA;

   478 		TPosition posR;

   479 		aPosInfoA.GetPosition(posA);

   480 		refPosInfo.GetPosition(posR);

   481 		

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

   483 			{

   484 			return EFalse;	

   485 			}

   486 		

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

   488 			{

   489 			return EFalse;	

   490 			}

   491 

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

   493 			{

   494 			return EFalse;	

   495 			}

   496 

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

   498 			{

   499 			return EFalse;	

   500 			}

   501 

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

   503 			{

   504 			return EFalse;	

   505 			}

   506 

   507 		return ETrue;

   508 		}

   509 		

   510 	inline static TBool ComparePositionInfoToNan(const TPositionInfo aPosInfoA)

   511 		{

   512 		TPosition pos;

   513 		aPosInfoA.GetPosition(pos);

   514 		

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

   516 			{

   517 			return EFalse;

   518 			}

   519 

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

   521 			{

   522 			return EFalse;

   523 			}

   524 			

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

   526 			{

   527 			return EFalse;

   528 			}

   529 			

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

   531 			{

   532 			return EFalse;

   533 			}

   534 			

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

   536 			{

   537 			return EFalse;

   538 			}

   539 			

   540 		return ETrue;

   541 			

   542 		}

   543 		

   544 	};

   545 

   546 //-------------------------------------------------------------------------------------------------

   547 

   548 #endif //__ARG_UTILS_H__