/*

* 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;

    /// Check if we have satellite data

    if(!(iStatus.Int() == KErrNone ||

         iStatus.Int() == KPositionPartialUpdate) )

	    {	    

	    iPositionInfo.ClearSatellitesInView();

		}	

    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();	       

				}

    	    //SortSatelliteDataL();

    	    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.

        */

            {

            iRequesting = EFalse;

            User::Leave( KErrAccessDenied );

            break;

            }

        case KErrCancel: // Postion update request cancelled

            {

            // We canceled the request so do nothing

            break;

            }

        case KPositionPartialUpdate: // Incomplete position information   

        {

        if ( iRequesting )

            {

            //DEBUG("KPositionPartialUpdate : NotifyPositionUpdate");

            iPositioner.NotifyPositionUpdate( iPositionInfo, iStatus );

            SetActive();

            }

        	break;

        }     

        case KErrTimedOut: // Position update timed out

        case KPositionQualityLoss: //GPS not connected

            {

            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:

            {  

            if(iStatus.Int() != KPositionPartialUpdate )

                {

                iDeviceStatus = EDeviceNotFound;

                iPositionInfo.ClearSatellitesInView();

                iWaitingGpsData = EFalse;                

                }

            // added for TSW error.    

            if(iStatus.Int() == KPositionPartialUpdate )

                {

                //SortSatelliteDataL();

                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;

            }

        }

    /*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: