--- a/basiclocationinfodisplay/blid/engine/src/CBlidLocation.cpp Thu Aug 19 09:48:36 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1474 +0,0 @@
-/*
-* 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
-