/*

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

        }

    }