--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/basiclocationinfodisplay/blid/engine/src/CBlidLocation.cpp Wed Sep 01 12:31:27 2010 +0100
@@ -0,0 +1,1474 @@
+/*
+* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implemenation of CBlidLocation class which provides access to blid location and satellite information
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <lbs.h>
+#include <lbscommon.h>
+#include <inetprottextutils.h>
+#include <lbsposition.h>
+#include <lbssatellite.h>
+
+#include "CBlidLocation.h"
+#include "MBlidEngObserver.h"
+#include "blidengconsts.h"
+#include "blidcommonconsts.h"
+#include "Blid.hrh"
+#include "cblidmoduleinfoobserver.h"
+
+#ifdef _DEBUG
+#include "Debug.h"
+#endif
+
+// FORWARD DECLARATION
+TInt TimerCallBackFunctionL(TAny* aPtr);
+TInt SortCriteria(const TSatelliteData& aCurrent, const TSatelliteData& aNext);
+
+// ============================ MEMBER FUNCTIONS ==============================
+// ----------------------------------------------------------------------------
+// CBlidLocation::CBlidLocation
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// ----------------------------------------------------------------------------
+//
+CBlidLocation::CBlidLocation(RPositionServer& aServer, CBlidEng& aEngine )
+ : CActive(EPriorityStandard)
+ ,iServer( aServer ), iRequesting( EFalse ),
+ iOnlineMode( EFalse ),iIsDistance(ETrue),
+ iDistanceTravelled(0),iIsTripStart(EFalse),
+ iIsTripNotStart(ETrue),iIsTripClear(EFalse),
+ iIsTripReset(EFalse),iEngine(aEngine)
+
+ {
+ CActiveScheduler::Add( this );
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ConstructL
+// Symbian 2nd phase constructor can leave.
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ConstructL( )
+ {
+ iSatelliteCapability = IsSatelliteCapabilityL();
+ //User::LeaveIfError(iPositioner.Open( iServer ));
+ // get the number of modules
+ GetModuleInfoNotificationL();
+ // and registered for notification
+ iModuleInfoObserv = CBlidModuleinfoObserver::NewL( iServer, *this );
+ iModuleInfoObserv->StartNotification();
+
+ //initialize iSpeedAverage
+ TRealX temp;
+ temp.SetNaN();
+ iSpeedAverage = temp;
+ iHeading = 0;
+ iGPSDataAvailable = EFalse;
+ iTripAverageSpeed = 0.0;
+ iTripMaxSpeed = 0.0;
+ iIsPreviousPositionUpdated = EFalse;
+ iWaitingGpsData = ETrue;
+ iIsDistanceTravelled = ETrue;
+ iRegisteredViewId = EBlidMainView;
+ iUpdateReceived = EFalse;
+ iDeviceStatus = EDeviceUnderConnection;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::NewL
+// Two-phased constructor.
+// ----------------------------------------------------------------------------
+//
+CBlidLocation* CBlidLocation::NewL( RPositionServer& aServer, CBlidEng& aEngine )
+ {
+ CBlidLocation* self = new( ELeave ) CBlidLocation(aServer, aEngine);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self ); //self
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::~CBlidLocation
+// ----------------------------------------------------------------------------
+//
+CBlidLocation::~CBlidLocation()
+ {
+ Cancel();
+ iPositioner.Close();
+ iSpeedArray.Close();
+ if(iTimer)
+ {
+ delete iTimer;
+ iTimer = NULL;
+ }
+ iModuleInfoArray.Reset();
+ delete iModuleInfoObserv;
+ iSortedSatData.Reset();
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetObserver
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetObserver(MBlidEngObserver& aObserver, TInt aViewId)
+ {
+ iObserver = &aObserver;
+ iRegisteredViewId = aViewId;
+ // added to fix TSW error
+ iLastGoodFixTime.UniversalTime();
+
+ if(iUpdateReceived)
+ {
+ SetUpdateOptions();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::RemoveModelObserver
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::RemoveModelObserver()
+ {
+ iObserver = NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::InitialLocationRequestL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::InitialLocationRequestL( const TDesC& aSrvName )
+ {
+ User::LeaveIfError(iPositioner.Open( iServer ));
+
+ User::LeaveIfError(iPositioner.SetRequestor(
+ CRequestor::ERequestorService,
+ CRequestor::EFormatApplication,
+ aSrvName ));
+ SetUpdateOptions();
+ iRequesting = ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CurrentPosition
+// ----------------------------------------------------------------------------
+//
+TPosition& CBlidLocation::GetCurrentPosition()
+ {
+ return iPosition;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsSatelliteCapability
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsSatelliteCapabilityL()
+ {
+ TUint count = 0;
+ User::LeaveIfError( iServer.GetNumModules(count) );
+ TPositionModuleInfo moduleInfo;
+
+ for( TUint i = 0; i < count; i++ )
+ {
+ User::LeaveIfError( iServer.GetModuleInfoByIndex( i, moduleInfo ) );
+ if ( moduleInfo.Capabilities() &
+ TPositionModuleInfo::ECapabilitySatellite )
+ {
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetCourseInfo
+// ----------------------------------------------------------------------------
+//
+TCourse& CBlidLocation::GetCourse()
+ {
+ return iCourse;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CancelRequest
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::CancelRequest()
+ {
+ Cancel();
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::StopRequesting
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::StopRequesting()
+ {
+ iOnlineMode = EFalse;
+ iRequesting = EFalse;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::StartRequesting
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::StartRequesting()
+ {
+ if ( !IsActive() )
+ {
+ SetUpdateOptions();
+ }
+ iRequesting = ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsOnline
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsOnline()
+ {
+ return iOnlineMode;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SatelliteCapability
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::SatelliteCapability()
+ {
+ return iSatelliteCapability;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SpeedAverage
+// ----------------------------------------------------------------------------
+//
+TReal CBlidLocation::SpeedAverage()
+ {
+ return iSpeedAverage;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::MaxSpeed
+// ----------------------------------------------------------------------------
+//
+TReal CBlidLocation::MaxSpeed()
+ {
+ return iMaxSpeed;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::WaitingGPSData
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::WaitingGPSData()
+ {
+ return iWaitingGpsData;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsGPSDeviceConnected
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsGPSDeviceConnected()
+ {
+ return (iDeviceStatus == EDeviceConnected);
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::RunL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::RunL()
+ {
+ iPosStatus = iStatus;
+
+ iDeviceStatus = EDeviceConnected;
+ SortSatelliteDataL();
+
+ switch (iStatus.Int())
+ {
+ //case KPositionPartialUpdate:
+ case KErrNone: // Success
+ {
+ iOnlineMode = ETrue;
+ iUpdateReceived = ETrue;
+ iGPSDataAvailable = ETrue;
+ iPositionInfo.GetPosition(iPosition);
+ iPositionInfo.GetCourse(iCourse);
+ iLastGoodFixTime.UniversalTime();
+
+ CalculateCourse();
+
+ if (iIsTripStart)
+ {
+ if (!iIsPreviousPositionUpdated)
+ {
+ iIsPreviousPositionUpdated = ETrue;
+ iPrevPosition = GetCurrentPosition();
+ }
+ UpdateTripData();
+ }
+ if (iObserver)
+ {
+ iObserver->NotifyL(iOnlineMode);
+ }
+ if (iRequesting)
+ {
+ //DEBUG("KErrNone : NotifyPositionUpdate");
+ iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
+ SetActive();
+ }
+ break;
+ }
+ case KErrAccessDenied:
+ /*
+ Happens if we don't specify requestor information.
+ This condition should not be encountered.
+ */
+ {
+ iPositionInfo.ClearSatellitesInView();
+ iRequesting = EFalse;
+ User::Leave(KErrAccessDenied);
+ break;
+ }
+ case KErrCancel: // Postion update request cancelled
+ {
+ // We canceled the request so do nothing
+ iPositionInfo.ClearSatellitesInView();
+ break;
+ }
+ case KPositionPartialUpdate: // Incomplete position information
+ {
+
+ TTime now;
+ now.UniversalTime();
+ TTimeIntervalSeconds secondsSinceLastGoodFix;
+ now.SecondsFrom(iLastGoodFixTime, secondsSinceLastGoodFix);
+ if (secondsSinceLastGoodFix.Int() > 15)
+ {
+ iLastGoodFixTime.UniversalTime();
+ if (iObserver)
+ {
+ iObserver->NotifyErrorL(KErrTimedOut);
+ }
+ }
+
+ else
+ {
+ iLastGoodFixTime.UniversalTime();
+ }
+ // end of addition for TSW error
+
+ iGPSDataAvailable = EFalse;
+ iUpdateReceived = ETrue;
+
+ // All cases are errors and hence go to offline mode
+ iOnlineMode = EFalse;
+ if (iObserver)
+ {
+ iObserver->NotifyErrorL(iStatus.Int());
+ }
+ if (iRequesting)
+ {
+ iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
+ SetActive();
+ }
+ break;
+ }
+
+ case KErrTimedOut: // Position update timed out
+ case KPositionQualityLoss: //GPS not connected
+ {
+ iPositionInfo.ClearSatellitesInView();
+ iUpdateReceived = ETrue;
+ iGPSDataAvailable = EFalse;
+ if (iIsTripStart && !iIsTripClear)
+ {
+ iTripGPSDataLost = ETrue;
+ }
+ // Leaving break is intentional
+ }
+ //-fallthrough
+ case KErrNotFound: // No PSY selected.
+ case KErrUnknown: // This will be returned by MLFW
+ case KErrArgument:
+
+ /*
+ PSY does not support the information type specified
+ by BLID.
+ */
+ default:
+ {
+ iDeviceStatus = EDeviceNotFound;
+ iWaitingGpsData = EFalse;
+ if (iObserver)
+ {
+ iObserver->NotifyErrorL(KErrNotFound);
+ }
+ if (iRequesting)
+ {
+ iPositioner.NotifyPositionUpdate(iPositionInfo, iStatus);
+ SetActive();
+ }
+ }
+ break;
+ }
+ /*if( iStatus.Int() != KErrCancel )
+ {
+ //DEBUG("RUNL : SetUpdateOptions");
+ SetUpdateOptions();
+ }*/
+ if (iStatus.Int() != KPositionPartialUpdate)
+ {
+ iWaitingGpsData = CheckIfWaitingGPSData();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetUpdateOptions
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetUpdateOptions()
+ {
+ if(IsActive())
+ {
+ Cancel();
+ }
+ // update interval
+ TInt intervalTime = KMidIntervalTime;
+
+ if(iEngine.AppMode() == CBlidEng::EAppBackground) // If application is in background mode
+ {
+ TRAP_IGNORE(UpdateIntervalL( KMaxIntervalTime ));
+ if ( iRequesting )
+ {
+ iPositioner.NotifyPositionUpdate( iPositionInfo, iStatus );
+ SetActive();
+ }
+ return;
+ }
+
+ switch(iRegisteredViewId)
+ {
+ case EBlidNavigationView:
+ {
+ TReal32 distance;
+ TInt retVal;
+ retVal = iEngine.GetDistanceToDestination(distance);
+ if(retVal == KErrNone)
+ {
+ if(distance <= KBlidHundredMeters)
+ {
+ intervalTime = KShortIntervalTime;
+ }
+ else if(distance > KBlidHundredMeters &&
+ distance < KBlidOneKilometer)
+ {
+ intervalTime = KMidIntervalTime;
+ }
+ else
+ {
+ intervalTime = KMaxIntervalTime;
+ }
+ }
+ else
+ {
+ intervalTime = KShortIntervalTime;
+ }
+ break;
+ }
+ case EBlidTripMeterView:
+ {
+ if(iDistanceTravelled < KBlidHundredMeters)
+ {
+ intervalTime = KShortIntervalTime;
+ }
+ else if(iDistanceTravelled > KBlidHundredMeters &&
+ iDistanceTravelled < KBlidOneKilometer)
+ {
+ intervalTime = KMidIntervalTime;
+ }
+ else
+ {
+ intervalTime = KMaxIntervalTime;
+ }
+ break;
+ }
+ case EBlidMainView:
+ default:
+ {
+ intervalTime = KMidIntervalTime;
+ break;
+ }
+ }
+ TRAP_IGNORE(UpdateIntervalL( intervalTime ));
+ if ( iRequesting )
+ {
+ iPositioner.NotifyPositionUpdate( iPositionInfo, iStatus );
+ SetActive();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::DoCancel
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::DoCancel()
+ {
+ iPositioner.CancelRequest( EPositionerNotifyPositionUpdate );
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::RunError
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::RunError(TInt aError)
+ {
+ if ( iObserver && aError != KBlidLeaveExit )
+ {
+ TRAPD(error,iObserver->NotifyErrorL( aError ));
+ if(error != KErrNone)
+ {
+ return error;
+ }
+ }
+ return aError;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::UpdateIntervalL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::UpdateIntervalL( const TInt aIntervalTime )
+ {
+ iCurrentUpdateInterval = aIntervalTime;
+ TPositionUpdateOptions updateOptions;
+ updateOptions.SetUpdateInterval(TTimeIntervalMicroSeconds(aIntervalTime));
+ updateOptions.SetAcceptPartialUpdates( ETrue );
+ if(iUpdateReceived)
+ {
+ updateOptions.SetUpdateTimeOut( TTimeIntervalMicroSeconds(KUpdateIntervalTimeOut));
+ }
+ else
+ {
+ updateOptions.SetUpdateTimeOut( TTimeIntervalMicroSeconds(KStartUpdateIntervalTimeOut));
+ }
+ User::LeaveIfError( iPositioner.SetUpdateOptions(updateOptions) );
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetCurrentUpdateInterval
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation:: GetCurrentUpdateInterval(TInt& aInterval)
+ {
+ aInterval = iCurrentUpdateInterval;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetPositionInfoStatus
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::GetPositionInfoStatus()
+ {
+ return iPosStatus.Int();
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CheckIfWaitingGPSData
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::CheckIfWaitingGPSData()
+ {
+ if(iDeviceStatus == EDeviceUnderConnection)
+ {
+ return ETrue;
+ }
+
+ // If none of the above then check satellite status
+ TInt num = iPositionInfo.NumSatellitesInView();
+ if(num > 0)
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetRegisteredViewId
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::GetRegisteredViewId()
+ {
+ return iRegisteredViewId;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetModuleInfoStatus
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetModuleInfoStatus(TPositionModuleStatusBase& aPosModuleStatus)
+ {
+ // This function scan through the all satellite and selected PSY
+ // and check the status of those PSY's if those are in Device err state.
+ //
+ TUint numberOfModules;
+ TPositionModuleInfo moduleInfo;
+ numberOfModules = iModuleInfoArray.Count();
+
+ if( numberOfModules > 0)
+ {
+ for( TInt i = 0; i < numberOfModules; i++ )
+ {
+ moduleInfo = iModuleInfoArray[i];
+ if ( (moduleInfo.Capabilities() &
+ TPositionModuleInfo::ECapabilitySatellite ) &&
+ moduleInfo.IsAvailable())
+ {
+ TPositionModuleId moduleId = moduleInfo.ModuleId();
+ iServer.GetModuleStatus(aPosModuleStatus, moduleId);
+
+ TPositionModuleStatus lPosModuleStatus;
+ iServer.GetModuleStatus(lPosModuleStatus, moduleId);
+ TInt resulterr = lPosModuleStatus.DeviceStatus();
+
+ if( (resulterr == TPositionModuleStatus::EDeviceError ) ||
+ (resulterr == TPositionModuleStatus::EDeviceInactive ) ||
+ (resulterr == TPositionModuleStatus::EDeviceStandBy ) )
+ {
+ continue;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetNumOfSatellitesL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetNumOfSatellitesL(TInt& aNumSatellites)
+ {
+ TSatelliteData tempSatelliteData;
+ TPosition CurrentPosition;
+ TInt totalStrength = 0;
+ TInt noOfSatUsed = iPositionInfo.NumSatellitesUsed();
+ TInt noOfSatInView = iPositionInfo.NumSatellitesInView();
+ iPositionInfo.GetPosition( CurrentPosition );
+ TBool isLat = Math::IsNaN( CurrentPosition.Latitude() );
+ TBool isLong = Math::IsNaN( CurrentPosition.Longitude () );
+ TBool isAlt = Math::IsNaN( CurrentPosition.Altitude () );
+
+ if( noOfSatUsed >= 4 && noOfSatInView > 4 )
+ {
+ for(TInt i = 0;i < noOfSatUsed ;i++ )
+ {
+ User::LeaveIfError(iPositionInfo.GetSatelliteData(i,tempSatelliteData));
+ totalStrength += tempSatelliteData.SignalStrength();
+ }
+ TInt avgStrength = totalStrength / noOfSatUsed;
+ if( avgStrength >= 40 &&
+ !isLat &&
+ !isLong &&
+ !isAlt )
+ {
+ aNumSatellites = 4;
+ }
+ else
+ {
+ aNumSatellites = 3;
+ }
+ }
+ else if ( noOfSatUsed < 4 && noOfSatInView >= 4 )
+ {
+ aNumSatellites = 2;
+ }
+ else if ( noOfSatUsed < 4 && noOfSatInView < 4 )
+ {
+ aNumSatellites = 1;
+ }
+ else
+ {
+ aNumSatellites = 0;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetMaxSpeed
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ResetMaxSpeed()
+ {
+ iMaxSpeed = 0.0;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetAvgSpeed
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ResetAvgSpeed()
+ {
+ iSpeedAverage= 0.0;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CalculateTripTimeL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::CalculateTripTimeL()
+ {
+ TTime curTime;
+ curTime.UniversalTime();
+ curTime.SecondsFrom(iInitTripTime,iTripInterval);
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CalculateTotalTimeL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::CalculateTotalTimeL()
+ {
+ TTime curTime;
+ curTime.UniversalTime();
+ if( iIsTripStart )
+ {
+ curTime.SecondsFrom(iInitViewTime,iTotalInterval);
+ }
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::UpdateTripData
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::UpdateTripData( )
+ {
+ if( iIsTripStart )
+ {
+ TReal32 distance;
+ TPosition& pos = GetCurrentPosition();
+ TReal32 max = Max(pos.HorizontalAccuracy(), iPrevPosition.HorizontalAccuracy());
+
+ if(iPrevPosition.Distance(pos, distance) == KErrNone)
+ {
+ TBool fixConsidered = EFalse;
+ if( distance > max )
+ {
+ iDistanceTravelled += distance;
+ iTotalDistanceTravelled += distance;
+ iPrevPosition = TPosition(pos);
+ fixConsidered = ETrue;
+ }
+ else
+ {
+ TReal32 speed = iCourse.Speed();
+ if(speed > KBlidCutOffSpeed)
+ {
+ iDistanceTravelled += distance;
+ iTotalDistanceTravelled += distance;
+ iPrevPosition = TPosition(pos);
+ fixConsidered = ETrue;
+ }
+ }
+ if(fixConsidered)
+ {
+ // Evaluated Trip Speeds if fix considered
+ TReal32 currentSpeed = iCourse.Speed();
+ if( currentSpeed > iTripMaxSpeed)
+ {
+ iTripMaxSpeed = currentSpeed;
+ }
+
+ TInt time = iTripInterval.Int();
+ iTripAverageSpeed = iDistanceTravelled / time;
+
+ if(iTripAverageSpeed > iTripMaxSpeed)
+ {
+ iTripAverageSpeed = iTripMaxSpeed;
+ }
+ }
+ }
+ else
+ {
+ iDistanceTravelled = 0;
+ iTotalDistanceTravelled = 0;
+ }
+
+ iIsDistanceTravelled = ETrue;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTripTime
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetTripTime( TTimeIntervalSeconds& aTime )
+ {
+ aTime = iTripInterval;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTripTime
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetTotalTime( TTimeIntervalSeconds& aTime )
+ {
+ aTime = iTotalInterval;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsTripDistanceTravelled
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsTripDistanceTravelled( )
+ {
+ return iIsDistanceTravelled;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTripDistance
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetTripDistance(TReal32& aDistance )
+ {
+ aDistance = iDistanceTravelled;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTotalDistance
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetTotalDistance(TReal32& aDistance )
+ {
+ aDistance = iTotalDistanceTravelled;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsTotalDistanceTravelled
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsTotalDistanceTravelled( )
+ {
+ return iIsDistance;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetTripStartL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetTripStartL()
+ {
+ if( !iIsTripStart )
+ {
+ iIsTripStart = ETrue;
+ iIsTripNotStart = EFalse;
+ iIsTripClear = EFalse;
+ iInitTripTime.UniversalTime();
+ iInitViewTime.UniversalTime();
+ iDistanceTravelled = 0.0;
+ if(iOnlineMode)
+ {
+ iPrevPosition = GetCurrentPosition();
+ iIsPreviousPositionUpdated = ETrue;
+ }
+ else
+ {
+ iIsPreviousPositionUpdated = EFalse;
+ }
+
+ if(iTimer)
+ {
+ delete iTimer;
+ iTimer = NULL;
+ }
+
+ iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ TCallBack callback(TimerCallBackFunctionL, this);
+ iTimer->Start( TTimeIntervalMicroSeconds32(1000000),
+ TTimeIntervalMicroSeconds32(1000000),
+ callback );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::HasTripStarted
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::HasTripStarted()
+ {
+ return iIsTripStart;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetTripStop
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetTripStop()
+ {
+ iIsTripStart = EFalse;
+ //iIsTripNotStart = EFalse;
+ if(iOnlineMode)
+ {
+ iWasGPSDataAvailableOnTripStop = ETrue;
+ }
+ else
+ {
+ iWasGPSDataAvailableOnTripStop = EFalse;
+ }
+ iStoppedTime.UniversalTime();
+ if(iTimer)
+ {
+ delete iTimer;
+ iTimer = NULL;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::HasTripStarted
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::HasTripNotStarted()
+ {
+ return iIsTripNotStart;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::HasTripStarted
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::WasGPSAvailableOnTripStop()
+ {
+ return iWasGPSDataAvailableOnTripStop;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetTrip
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ResetTrip()
+ {
+ if(iIsTripStart == EFalse)
+ {
+ iIsTripReset = ETrue;
+ }
+ else
+ {
+ iIsTripReset = EFalse;
+ }
+
+ iDurationInSeconds = 0.0;
+ iDistanceTravelled = 0.0;
+ iTripTime = 0;
+ iTripInterval = 0;
+ iInitTripTime.UniversalTime();
+ iTripAverageSpeed = 0.0;
+ iTripMaxSpeed = 0.0;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::Restart
+// ----------------------------------------------------------------------------
+//
+/*void CBlidLocation::Restart()
+ {
+ iDurationInSeconds = 0.0;
+ iDistanceTravelled = 0.0;
+ //iTotalDistanceTravelled = 0.0;
+ iTotalDurationInSeconds = 0.0;
+ iWasGPSDataAvailableOnTripStop = EFalse;
+ iTripTime = 0;
+ iTotalTime = 0;
+ iTripInterval = 0;
+ iTotalInterval = 0;
+ iInitViewTime.UniversalTime();
+ iInitTripTime.UniversalTime();
+ iIsTripNotStart = EFalse;
+ iTripAverageSpeed = 0.0;
+ iTripMaxSpeed = 0.0;
+ }*/
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetTripResumeL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetTripResumeL()
+ {
+ iIsTripStart = ETrue;
+ iIsTripNotStart = EFalse;
+ iWasGPSDataAvailableOnTripStop = EFalse;
+ iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
+ TCallBack callback(TimerCallBackFunctionL, this);
+ iTimer->Start( TTimeIntervalMicroSeconds32(1000000),
+ TTimeIntervalMicroSeconds32(1000000),
+ callback );
+ TTime curTime;
+ curTime.UniversalTime();
+ TTimeIntervalMicroSeconds interval;
+ interval = curTime.MicroSecondsFrom(iStoppedTime);
+
+ if(iStoppedTime > iInitViewTime )
+ {
+ iInitViewTime = iInitViewTime + interval;
+ }
+
+ if(iIsTripReset)
+ {
+ iInitTripTime.UniversalTime();
+ iIsTripReset = EFalse;
+ }
+ else if(iStoppedTime > iInitTripTime )
+ {
+ iInitTripTime = iInitTripTime + interval;
+ }
+
+ if(iIsTripStart)
+ {
+ CalculateTripTimeL();
+ }
+ CalculateTotalTimeL();
+
+ if(iObserver)
+ {
+ if(iOnlineMode)
+ {
+ iObserver->NotifyL(iOnlineMode);
+ }
+ else
+ {
+ iObserver->NotifyErrorL(KErrUnknown);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetTripClear
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetTripClear()
+ {
+ iIsTripClear = ETrue;
+ iIsTripStart = EFalse;
+ iIsTripReset = EFalse;
+ iIsDistance = ETrue;
+ iWasGPSDataAvailableOnTripStop = EFalse;
+ iTripAverageSpeed = 0.0;
+ iTripMaxSpeed = 0.0;
+ iTripGPSDataLost = EFalse;
+ iIsTripNotStart = ETrue;
+
+ iDurationInSeconds = 0.0;
+ iDistanceTravelled = 0.0;
+ iTotalDurationInSeconds = 0.0;
+ iTripTime = 0;
+ iTotalTime = 0;
+ iTripInterval = 0;
+ iTotalInterval = 0;
+ iInitViewTime.UniversalTime();
+ iInitTripTime.UniversalTime();
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsTripCleared
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsTripCleared()
+ {
+ return iIsTripClear;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetTripClear
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ResetTripClear()
+ {
+ iIsTripClear = EFalse;
+ iInitTripTime.UniversalTime();
+ iInitViewTime.UniversalTime();
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetTripClear
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsTripReset()
+ {
+ return iIsTripReset;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::TimerCallBackL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::TimerCallBackL()
+ {
+ if(iIsTripStart)
+ {
+ CalculateTripTimeL();
+ }
+ CalculateTotalTimeL();
+
+ if(iObserver)
+ {
+ if(iOnlineMode)
+ {
+ iObserver->NotifyL(iOnlineMode);
+ }
+ else
+ {
+ iObserver->NotifyErrorL(KErrUnknown);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetHeading
+// ----------------------------------------------------------------------------
+//
+TReal32 CBlidLocation::GetHeading()
+ {
+ return iHeading;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CalculateCourse
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::CalculateCourse()
+ {
+ TReal32 distance;
+ TPosition& pos = GetCurrentPosition();
+ TReal32 max = Max(pos.HorizontalAccuracy(), iPrevPosition.HorizontalAccuracy());
+
+ if(iPrevCoursePosition.Distance(pos, distance) == KErrNone)
+ {
+ if( distance > 0.2 * max )
+ {
+ iHeading = iCourse.Heading();
+ iPrevCoursePosition = TPosition(pos);
+ }
+ }
+ else
+ {
+ iPrevCoursePosition = TPosition(pos);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::CheckGPSAvailability
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::CheckGPSAvailability()
+ {
+ TPositionModuleStatus lPosModuleStatus;
+ GetModuleInfoStatus(lPosModuleStatus);
+ TInt retVal = lPosModuleStatus.DeviceStatus();
+
+
+ if ((retVal == TPositionModuleStatus::EDeviceError) ||
+ (retVal == TPositionModuleStatus::EDeviceStandBy) ||
+ (retVal == TPositionModuleStatus::EDeviceUnknown) )
+ {
+ // GPS device unavailable
+ return 0;
+ }
+ else if( (retVal == TPositionModuleStatus::EDeviceReady) ||
+ (retVal == TPositionModuleStatus::EDeviceActive) ||
+ (retVal == TPositionModuleStatus::EDeviceInactive) )
+ {
+ // GPS device is paired and available
+ return 1;
+ }
+ // GPS device connections is being established
+ return -1;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsGPSDataAvailable
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsGPSDataAvailable()
+ {
+ return iGPSDataAvailable;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::WasGPSDataLost
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::WasGPSDataLost()
+ {
+ return iTripGPSDataLost;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetGPSDataAvailability
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetGPSDataAvailability(TBool aAvailability)
+ {
+ iTripGPSDataLost = aAvailability;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTripAverageSpeed
+// ----------------------------------------------------------------------------
+//
+TReal32 CBlidLocation::GetTripAverageSpeed()
+ {
+ return iTripAverageSpeed;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetTripAverageSpeed
+// ----------------------------------------------------------------------------
+//
+TReal32 CBlidLocation::GetTripMaxSpeed()
+ {
+ TReal32 currentSpeed = iCourse.Speed();
+ return currentSpeed;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetModuleInfoNotification
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::GetModuleInfoNotificationL()
+ {
+ iModuleInfoArray.Reset();
+ User::LeaveIfError( iServer.GetNumModules(iModuleCount) );
+ TPositionModuleInfo moduleInfo;
+
+ for( TUint i = 0; i < iModuleCount; i++ )
+ {
+ User::LeaveIfError( iServer.GetModuleInfoByIndex( i, moduleInfo ) );
+ iModuleInfoArray.Append(moduleInfo);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SetNavigationStart
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SetNavigationStart( TBool aNavigationStart )
+ {
+ if( !aNavigationStart )
+ {
+ iIsTripStart = EFalse;
+ }
+ else
+ {
+ iIsTripStart = ETrue;
+ }
+
+ if( !iIsTripStart )
+ {
+ // delete the timer because the stop trip will not be get called
+ // or else it will leads to memory leak
+ if(iTimer)
+ {
+ delete iTimer;
+ iTimer = NULL;
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::ResetOdometerValue
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::ResetOdometerValue()
+ {
+ iTotalDistanceTravelled = 0.0;
+ }
+
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsSatCapablePsyAvailable
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsSatCapablePsyAvailable()
+ {
+ TUint numberOfModules;
+ TPositionModuleInfo moduleInfo;
+ numberOfModules = iModuleInfoArray.Count();
+
+ if( numberOfModules > 0)
+ {
+ moduleInfo = iModuleInfoArray[ 1 ];
+ if ( (moduleInfo.Capabilities() &
+ TPositionModuleInfo::ECapabilitySatellite ) &&
+ !moduleInfo.IsAvailable() )
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::NumberOfSatellitesVisible
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::NumberOfSatellitesVisible()
+ {
+ return iPositionInfo.NumSatellitesInView();
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::IsSatellitesUsed
+// ----------------------------------------------------------------------------
+//
+TBool CBlidLocation::IsSatellitesUsed( TInt aIndex )
+ {
+ TBool lResult = EFalse;
+ TSatelliteData satData;
+
+ if( GetSatelliteData( aIndex, satData ) != KErrNotFound)
+ {
+ lResult = satData.IsUsed();
+ }
+ return lResult;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::SortSatelliteDataL
+// ----------------------------------------------------------------------------
+//
+void CBlidLocation::SortSatelliteDataL()
+ {
+ TSatelliteData tempSatelliteData;
+ TLinearOrder<TSatelliteData> order(SortCriteria);
+ iSortedSatData.Reset();
+ TInt satellitesInView = iPositionInfo.NumSatellitesInView();
+ for(TInt i = 0;i < satellitesInView ;i++ )
+ {
+ User::LeaveIfError(iPositionInfo.GetSatelliteData(i,tempSatelliteData));
+ TInt signalsth = tempSatelliteData.SignalStrength();
+ iSortedSatData.InsertInOrderAllowRepeats(tempSatelliteData, order);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetSatelliteSignalStrength
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::GetSatelliteSignalStrength( TInt aIndex )
+ {
+ TSatelliteData satData;
+
+ if( GetSatelliteData( aIndex, satData ) != KErrNotFound )
+ {
+ if( satData.SignalStrength() < KMinSatelliteSignalStrength )
+ {
+ return 0;
+ }
+ else if( satData.SignalStrength() == KMinSatelliteSignalStrength )
+ {
+ return 1;
+ }
+ else if( satData.SignalStrength() > KMinSatelliteSignalStrength &&
+ satData.SignalStrength() < KMidSatelliteSignalStrength )
+ {
+ return 2;
+ }
+ else if( satData.SignalStrength() > KMidSatelliteSignalStrength &&
+ satData.SignalStrength() < KMaxSatelliteSignalStrength )
+ {
+ return 3;
+ }
+ else if( satData.SignalStrength() > KMaxSatelliteSignalStrength )
+ {
+ return 4;
+ }
+ }
+ return 0;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetSatelliteData
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::GetSatelliteData( TUint aIndex,
+ TSatelliteData& aSatelliteData)
+ {
+ if( aIndex >= iSortedSatData.Count() )
+ {
+ return KErrNotFound;
+ }
+ aSatelliteData = iSortedSatData[aIndex];
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CBlidLocation::GetSatelliteNo
+// ----------------------------------------------------------------------------
+//
+TInt CBlidLocation::GetSatelliteNo( TInt aIndex )
+ {
+ TSatelliteData satData;
+
+ if( GetSatelliteData( aIndex, satData ) != KErrNotFound)
+ {
+ return satData.SatelliteId();
+ }
+ return 0;
+ }
+
+// ----------------------------------------------------------------------------
+// SortCriteria
+// ----------------------------------------------------------------------------
+//
+TInt SortCriteria(const TSatelliteData& aFirst, const TSatelliteData& aNext)
+ {
+ if(aFirst.SatelliteId() > aNext.SatelliteId())
+ {
+ return 1;
+ }
+ else if(aFirst.SatelliteId() < aNext.SatelliteId())
+ {
+ return -1;
+ }
+ return 0;
+ }
+
+// ----------------------------------------------------------------------------
+// TimerCallBackFunctionL
+// ----------------------------------------------------------------------------
+//
+TInt TimerCallBackFunctionL(TAny* aPtr)
+ {
+ CBlidLocation* ptr = static_cast<CBlidLocation*>(aPtr);
+ ptr->TimerCallBackL();
+ return 1;
+ }
+
+// End of File
+