1 // Copyright (c) 2001-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 

    17 

    18 //  INCLUDES

    19 #include "tlbscalculationcheck.h"

    20 #include <e32math.h>

    21 

    22 

    23 //CONSTANTS

    24 const TReal KAccuracyHigh = 5.96E-8;

    25 const TReal KAccuracyMedium = 4E-5;

    26 const TReal KAccuracyLow = 4E-3;

    27 

    28 

    29 // C++ default constructor 

    30 T_LbsCalculationCheck::T_LbsCalculationCheck() :

    31     iErrorCode(KErrArgument),

    32     iBearingErrorCode(KErrArgument),

    33     iBearingDeltaErrorCode(KErrArgument),

    34     iSpeedErrorCode(KErrArgument),

    35     iMoveErrorCode(KErrArgument)

    36     {

    37     TRealX nan;

    38     nan.SetNaN();

    39     iDistance=nan;

    40     }

    41 

    42 T_LbsCalculationCheck::T_LbsCalculationCheck(const TPosition& aSourcePosition, const TPosition& aTargetPosition) :

    43     iSourcePosition(aSourcePosition),

    44     iTargetPosition(aTargetPosition),

    45     iErrorCode(KErrArgument),

    46     iBearingErrorCode(KErrArgument),

    47     iBearingDeltaErrorCode(KErrArgument),

    48     iSpeedErrorCode(KErrArgument),

    49     iMoveErrorCode(KErrNone)

    50     {

    51    

    52     }

    53 

    54 // C++ Constructor TDesC

    55 T_LbsCalculationCheck::T_LbsCalculationCheck(const TDesC& aDes)

    56     {

    57     TReal lat1;

    58     TReal long1;

    59     TReal lat2;

    60     TReal long2;

    61     TReal32 err1=0;

    62     TReal32 err2=0;

    63     TReal time1=0;

    64     TReal time2=0;

    65   

    66     TLex line(aDes);

    67     line.Mark();

    68     TInt index=0;

    69     while (line.Peek() != '\n' && !(line.Peek()).Eos())

    70         {

    71         line.Inc();

    72         if (line.Peek() == '\t')

    73             {

    74             TPtrC token = line.MarkedToken();

    75             TLex val(token);              

    76             switch(index)

    77                 {

    78                 case ELat1Index:

    79                     val.Val(lat1, TChar(','));  

    80                     break;

    81                 case ELong1Index:

    82                     val.Val(long1, TChar(','));

    83                     break;

    84                 case ELat2Index:

    85                     val.Val(lat2, TChar(','));

    86                     break;

    87                 case ELong2Index:

    88                     val.Val(long2, TChar(','));

    89                     break;

    90                 case EErr1Index:

    91                     val.Val(err1, TChar(','));

    92                     break;

    93                 case EErr2Index:

    94                     val.Val(err2, TChar(','));

    95                     break;

    96                 case ETime1Index:

    97                     val.Val(time1, TChar(','));

    98                     break;

    99                 case ETime2Index:

   100                     val.Val(time2, TChar(','));

   101                     break;

   102                 case EDistanceIndex:

   103                     val.Val(iDistance, TChar(','));

   104                     break;

   105                 case EErrorCodeIndex:

   106                     val.Val(iErrorCode);

   107                     break;

   108                 case EDeltaIndex:

   109                     val.Val(iDelta, TChar(','));

   110                     break;

   111                 case EBearingIndex:

   112                     val.Val(iBearing, TChar(','));

   113                     if (iBearing == 360.0)

   114                         iBearing = 0.0; 

   115                     break;

   116                 case EBearingErrorCodeIndex:

   117                     val.Val(iBearingErrorCode);

   118                     break;

   119                 case EBearingDelta:

   120                     val.Val(iBearingDelta, TChar(','));

   121                     break;

   122                 case EDeltaErrorCode:

   123                     val.Val(iBearingDeltaErrorCode);

   124                     break;

   125                 case ESpeedIndex:

   126                     val.Val(iSpeed, TChar(','));

   127                     break;

   128                 case ESpeedErrorCodeIndex:

   129                     val.Val(iSpeedErrorCode);

   130                     break;

   131                 case ESpeedDeltaIndex:

   132                     val.Val(iSpeedDelta, TChar(','));

   133                     break;

   134                 case EMoveErrorCodeIndex:

   135                     val.Val(iMoveErrorCode);

   136                     break;

   137                 }    

   138             line.Inc();

   139             line.Mark();

   140             ++index;

   141             }

   142         }

   143     iSourceLocality.SetCoordinate(lat1, long1, 5.0);

   144     iTargetLocality.SetCoordinate(lat2, long2, 100.0);

   145     

   146     iSourceLocality.SetHorizontalAccuracy(err1);

   147     iTargetLocality.SetHorizontalAccuracy(err2);

   148 

   149     iSourcePosition.SetCoordinate(lat1, long1, 5.0);

   150     iTargetPosition.SetCoordinate(lat2, long2, 100.0);

   151     iSourcePosition.SetHorizontalAccuracy(err1);

   152     iTargetPosition.SetHorizontalAccuracy(err2);

   153 

   154     TTime ttime1;

   155     TTime ttime2;

   156     

   157     ttime1.UniversalTime();

   158     ttime2.UniversalTime(); 

   159     

   160     if ((time1 < 1.0 || time2 < 1.0) && (time1 > -1.0 && time2 > -1.0))

   161         {

   162         time1 *= 1000000;    

   163         time2 *= 1000000;

   164         ttime1 += TTimeIntervalMicroSeconds((TInt)time1);

   165         ttime2 += TTimeIntervalMicroSeconds((TInt)time2);

   166         }

   167     else

   168         {

   169         

   170         ttime1 += TTimeIntervalSeconds((TInt)time1);

   171         ttime2 += TTimeIntervalSeconds((TInt)time2);

   172         }

   173    

   174     iSourcePosition.SetTime(ttime1);

   175     iTargetPosition.SetTime(ttime2);   

   176     }   

   177 

   178 TInt T_LbsCalculationCheck::CheckDistance()

   179     {

   180     TInt err=0;

   181     TReal32 distance;

   182     err = iSourceLocality.Distance(iTargetLocality, distance);

   183     

   184     if (err != iErrorCode)

   185         {

   186         iReturnedErrorCode = err;

   187         return KErrCalculationCheckErrorCode;

   188         }

   189     

   190     if(!err)

   191         {

   192         if (!Equals32(distance, iDistance, KAccuracyHigh))

   193             {

   194             iCalculated=distance;

   195             return KErrCalculationCheckDistance;

   196             }

   197         }

   198     return KErrNone;

   199     }

   200 

   201 TInt T_LbsCalculationCheck::CheckBearing()

   202     {

   203     TInt err=0;

   204     TReal32 bearing;

   205   

   206     err = iSourceLocality.BearingTo(iTargetLocality, bearing);

   207     

   208     if (err != iBearingErrorCode)

   209         {

   210         iReturnedErrorCode = err;

   211         return KErrCalculationCheckErrorCode;

   212         }

   213     

   214     if(!err)

   215         {

   216         TReal accuracy;

   217         if (bearing < 1 )

   218             {    

   219             accuracy=KAccuracyLow;

   220             }

   221         else

   222             {

   223             accuracy=KAccuracyHigh;

   224             }

   225 

   226         if (!Equals32(bearing, iBearing, accuracy))

   227             {

   228             iCalculated=bearing;

   229             

   230             return KErrCalculationCheckBearing;

   231             }

   232         }

   233 

   234     return KErrNone;

   235     }

   236     

   237 TInt T_LbsCalculationCheck::CheckDistanceCoordinate()

   238     {

   239     TInt err=0;

   240     TReal32 distance;

   241     

   242     TCoordinate source(iSourceLocality.Latitude(), iSourceLocality.Longitude());

   243     TCoordinate target(iTargetLocality.Latitude(), iTargetLocality.Longitude());

   244 

   245     err=source.Distance(target, distance);

   246     

   247     if (err != iErrorCode)

   248         {

   249         iReturnedErrorCode = err;

   250         return KErrCalculationCheckErrorCode;

   251         }

   252     if(!err)

   253         { 

   254         if (!Equals32(distance, iDistance, KAccuracyHigh))

   255             {

   256             iCalculated=distance;

   257             return KErrCalculationCheckDistance;

   258             }

   259         }

   260     return KErrNone;

   261     }

   262 

   263 TInt T_LbsCalculationCheck::CheckBearingCoordinate()

   264     {

   265     TReal32 bearing;

   266     

   267     TCoordinate source(iSourceLocality.Latitude(), iSourceLocality.Longitude());

   268     TCoordinate target(iTargetLocality.Latitude(), iTargetLocality.Longitude());

   269 

   270     TInt err=0;

   271     err=source.BearingTo(target, bearing);

   272     

   273     if (err != iBearingErrorCode)

   274         {

   275         iReturnedErrorCode = err;

   276         return KErrCalculationCheckErrorCode;

   277         }

   278     if(!err)

   279         {

   280         TReal accuracy;

   281         if (bearing < 1 )

   282             {    

   283             accuracy=KAccuracyLow;

   284             }

   285         else

   286             {

   287             accuracy=KAccuracyHigh;

   288             }

   289         if (!Equals32(bearing, iBearing, accuracy))

   290             {

   291             iCalculated=bearing;

   292             return KErrCalculationCheckBearing;

   293             }

   294         }

   295     return KErrNone;

   296     }

   297 

   298 TInt T_LbsCalculationCheck::CheckDistanceDelta()

   299     {

   300     TInt err=0;

   301     TReal32 distance;

   302     TReal32 delta;

   303 

   304     err = iSourceLocality.Distance(iTargetLocality, distance, delta);

   305     

   306     if (err != iErrorCode)

   307         {

   308         iReturnedErrorCode = err;

   309         return KErrCalculationCheckErrorCode;

   310         }

   311     if(!err)

   312         { 

   313         if (!Equals32(distance, iDistance, KAccuracyHigh) )

   314             {

   315             iCalculated=distance;

   316             return KErrCalculationCheckDistance;

   317             }

   318 

   319         if (!Equals32(delta, iDelta, KAccuracyLow))

   320             {

   321             iCalculated=delta;

   322             return KErrCalculationCheckDistanceDelta;

   323             }

   324         }

   325 

   326     return KErrNone;

   327     }

   328 

   329 TInt T_LbsCalculationCheck::CheckBearingDelta()

   330     {

   331     TReal32 bearing;

   332     TReal32 delta;

   333 

   334     TInt err=0;

   335     err = iSourceLocality.BearingTo(iTargetLocality, bearing, delta);

   336     

   337     if (err != iBearingDeltaErrorCode)

   338         {

   339         iReturnedErrorCode = err;

   340         return KErrCalculationCheckErrorCode;

   341         }

   342     if(!err)

   343         {

   344         TReal accuracy;

   345         if (bearing < 1 )

   346             {    

   347             accuracy=KAccuracyLow;

   348             }

   349         else

   350             {

   351             accuracy=KAccuracyHigh;

   352             }

   353 

   354         if (!Equals32(bearing, iBearing, accuracy) )

   355             {

   356             iCalculated=bearing;

   357             return KErrCalculationCheckDistance;

   358             }

   359 

   360         if (!Equals32(delta, iBearingDelta, KAccuracyHigh))

   361             {

   362             iCalculated=delta;

   363             return KErrCalculationCheckBearingDelta;

   364             }

   365         }

   366 

   367     return KErrNone;

   368     }

   369 

   370 TInt T_LbsCalculationCheck::CheckSpeed()

   371     {

   372     TInt err=0;

   373     TReal32 speed;

   374 

   375     err = iSourcePosition.Speed(iTargetPosition, speed);

   376     

   377     if (err != iSpeedErrorCode)

   378         {

   379         iReturnedErrorCode = err;

   380         return KErrCalculationCheckErrorCode;

   381         }

   382     

   383     if(!err)

   384         {

   385         if (!Equals32(speed, iSpeed, KAccuracyHigh))

   386             {

   387             iCalculated=speed;

   388             return KErrCalculationCheckSpeed;

   389             }

   390         }

   391     return KErrNone;    

   392     }

   393 

   394 TInt T_LbsCalculationCheck::CheckSpeedDelta()

   395     {

   396     TInt err=0;

   397     TReal32 speed;

   398     TReal32 delta;

   399 

   400     err = iSourcePosition.Speed(iTargetPosition, speed, delta);

   401     

   402     if (err != iSpeedErrorCode)

   403         {

   404         iReturnedErrorCode = err;

   405         return KErrCalculationCheckErrorCode;

   406         }

   407     

   408     if(!err)

   409         {

   410         if (!Equals32(speed, iSpeed, KAccuracyHigh))

   411             {

   412             iCalculated=speed;

   413             return KErrCalculationCheckSpeed;

   414             }

   415 

   416          if (!Equals32(delta, iSpeedDelta, KAccuracyHigh))

   417             {

   418             iCalculated=delta;

   419             return KErrCalculationCheckSpeedDelta;

   420             }

   421         }

   422 

   423     return KErrNone;    

   424     }

   425 

   426 TInt T_LbsCalculationCheck::CheckMove()

   427     {

   428     TInt err=0;

   429   

   430     TCoordinate source(iSourcePosition.Latitude(), iSourcePosition.Longitude());

   431     

   432     err=source.Move(iBearing, iDistance);

   433     

   434     if (err != iMoveErrorCode)

   435         {

   436         iReturnedErrorCode = err;

   437         return KErrCalculationCheckErrorCode;

   438         }

   439     

   440     if(!err)

   441         {

   442         if (iTargetPosition.Latitude() == 90.0 || iTargetPosition.Latitude() == -90.0)

   443             {

   444             if (!Equals32(source.Latitude(), iTargetPosition.Latitude(), KAccuracyMedium))

   445                 {

   446                 iCalcCoordinate=source;

   447                 return KErrCalculationCheckMove;

   448                 }

   449             }

   450         else

   451             {

   452             if (!Equals32(source.Latitude(), iTargetPosition.Latitude(), KAccuracyMedium) ||

   453                 !Equals32(source.Longitude(), iTargetPosition.Longitude(), KAccuracyMedium))

   454                 {

   455                 iCalcCoordinate=source;

   456                 return KErrCalculationCheckMove;

   457                 }

   458             }

   459         }

   460 

   461     return KErrNone;    

   462     }

   463 

   464 TBool T_LbsCalculationCheck::Equals32(const TReal aValue1, const TReal aValue2, const TReal aAccuracy)

   465     {

   466     TReal maxAllowedError = aAccuracy;

   467     

   468     TReal maxValue;

   469     aValue1 > aValue2 ? maxValue=aValue1 : maxValue=aValue2;

   470 

   471     while (maxValue >= 1.0)

   472         {

   473         maxValue /= 10.0;

   474         maxAllowedError *= 10.0;

   475         }

   476 

   477     TReal absError = Abs(aValue1-aValue2);

   478     

   479     return (absError < maxAllowedError); 

   480 

   481     }

   482 

   483 void T_LbsCalculationCheck::GetSourcePosition(TPosition& aSourcePosition) const

   484     {

   485     aSourcePosition=iSourcePosition;

   486     }

   487 

   488 void T_LbsCalculationCheck::GetTargetPosition(TPosition& aTargetPosition) const 

   489     {

   490     aTargetPosition=iTargetPosition;

   491     }

   492 

   493 void T_LbsCalculationCheck::GetCalcCoordinate(TCoordinate& aCoordinate) const

   494     {

   495     aCoordinate=iCalcCoordinate;

   496     }

   497     

   498 TReal T_LbsCalculationCheck::Distance() const

   499     {

   500     return iDistance;

   501     }

   502 

   503 TReal T_LbsCalculationCheck::Calculated() const

   504     {

   505     return iCalculated;

   506     }

   507    

   508 TReal T_LbsCalculationCheck::Delta() const

   509     {

   510     return iDelta;

   511     }

   512 

   513 TReal T_LbsCalculationCheck::BearingDelta() const

   514     {

   515     return iBearingDelta;

   516     }

   517 

   518 TInt T_LbsCalculationCheck::ErrorCode() const

   519     {

   520     return iErrorCode;

   521     }

   522 

   523 TInt T_LbsCalculationCheck::BearingErrorCode() const

   524     {

   525     return iBearingErrorCode;

   526     }

   527 

   528 TInt T_LbsCalculationCheck::SpeedErrorCode() const

   529     {

   530     return iSpeedErrorCode;

   531     }

   532 

   533 void T_LbsCalculationCheck::SetErrorCode(TInt aErrorCode)

   534     {

   535     iErrorCode=aErrorCode;

   536     }

   537 

   538 void T_LbsCalculationCheck::SetBearingErrorCode(TInt aErrorCode)

   539     {

   540     iBearingErrorCode=aErrorCode;

   541     }

   542 

   543 void T_LbsCalculationCheck::SetBearingDeltaErrorCode(TInt aErrorCode)

   544     {

   545     iBearingDeltaErrorCode=aErrorCode;

   546     }

   547 

   548 void T_LbsCalculationCheck::SetSpeedErrorCode(TInt aErrorCode)

   549     {

   550     iSpeedErrorCode=aErrorCode;

   551     }

   552 

   553 void T_LbsCalculationCheck::SetMoveErrorCode(TInt aErrorCode)

   554     {

   555     iMoveErrorCode=aErrorCode;

   556     }

   557 

   558 TInt T_LbsCalculationCheck::ReturnedErrorCode() const

   559     {

   560     return iReturnedErrorCode;

   561     }

   562 

   563 TReal T_LbsCalculationCheck::Bearing() const

   564     {

   565     return iBearing;

   566     }

   567 

   568 TReal T_LbsCalculationCheck::Speed() const

   569     {

   570     return iSpeed;

   571     }

   572 

   573 TReal T_LbsCalculationCheck::SpeedDelta() const

   574     {

   575     return iSpeedDelta;

   576     }

   577 

   578 //  End of File