// Copyright (c) 2004-2009 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:

// INCLUDE FILES

//

#include <e32std.h>

#include <e32math.h>

#include <lbspositioninfo.h> 

#include <lbssatellite.h>            // TPositionSatelliteInfo

#include "BTGPSLogging.h"

#include "BTGPSRequestHandler.h"

#include "BTGPSConstantsManager.h"

#include "BTGPSFix.h"

#include "BTGPSLogging.h"

#include "BTGPSNmeaParser.h"

#include "BTGPSNmeaBuffer.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

//The knots to m/s conversion multiplier

const TReal64 KKnotInMetersPerSecond = 0.5144;

//Hardcoded accuracy

const TReal32 KHorizontalAccuracy = 10.0;

const TReal32 KVerticalAccuracy = 30.0;

//Decimal seperator

const TUint8 KDecimalSeperator = '.';

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CBTGPSFix::CBTGPSFix

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CBTGPSFix::CBTGPSFix()

    {

    Reset();

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::SetNmeaBuffer

// Set NMEA Buffer

// -----------------------------------------------------------------------------

void CBTGPSFix::SetNmeaBuffer(CBTGPSNmeaBuffer* aNmeaBuffer)

    {

    iNmeaBuffer = aNmeaBuffer;

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::Reset

// Reset the fix parameters.

// -----------------------------------------------------------------------------

void CBTGPSFix::Reset()

    {

    TRACESTRING("CBTGPSFix::Reset")

    ResetFix();

    ResetGSVTime();

    iNumberOfSatellites = 0;

    iSatelliteArray.Reset();

    for(TInt i=0; i<KMaxGSVMessageNumber; i++)

        {

        iNMEAGSVCache[i].Zero();

        }

    //Reset NMEA Buffer

    if(iNmeaBuffer!=NULL)

        {

        iNmeaBuffer->ResetBuffer();

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ResetFix

// -----------------------------------------------------------------------------

void CBTGPSFix::ResetFix()

    {

    TRACESTRING("CBTGPSFix::ResetFix start...")

    TRealX nan;

    nan.SetNaN();

    ResetPosition();

    iSpeed=nan;

    iHeading=nan;

    iUsedSatellitesArray.Reset();

    iSatelliteTime = TTime(0);

    iHorizontalDoP = nan;

    iVerticalDoP = nan;

    iPositionDoP = nan;

    iSatellitesUsed = 0;

    //Clear the mask

    iReceivedMsgMask = 0;

    iGpsMode = EGpsModeSatellite;

    TRACESTRING("CBTGPSFix::ResetFix end")

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ResetGSVTime

// -----------------------------------------------------------------------------

void CBTGPSFix::ResetGSVTime()

    {

    TRACESTRING("CBTGPSFix::ResetGSVTime start...")

    iGsvTime = TTime(0);

    TRACESTRING("CBTGPSFix::ResetGSVTime end");

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ResetPosition

// 

// -----------------------------------------------------------------------------

void CBTGPSFix::ResetPosition()

    {

    TRACESTRING("CBTGPSFix::ResetPosition start...")

    TRealX nan;

    nan.SetNaN();

    iLatitude = nan;

    iLongitude = nan;

    iAltitude = nan;

    iTime = TTime(0);

    iValid = CBTGPSFix::EFixValidityUnkown;

    TRACESTRING("CBTGPSFix::ResetPosition end")

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::FixState

// -----------------------------------------------------------------------------

CBTGPSFix::TState CBTGPSFix::FixState() const

    {

    return iValid;

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::IsFixValid

// 

// -----------------------------------------------------------------------------

TBool CBTGPSFix::IsFixValid() const

    {

    return (iValid == EFixValid2D || iValid == EFixValid3D);

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::IfFullNmeaPatternReceived

// 

// -----------------------------------------------------------------------------

TBool CBTGPSFix::IfFullNmeaPatternReceived() const

    {

    return iReceivedMsgMask == (EReceivedGSA|EReceivedGGA|EReceivedRMC);

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::FixTime

// 

// -----------------------------------------------------------------------------

TTime CBTGPSFix::FixTime() const

    {

    return iTime;

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::GsvTime

// 

// -----------------------------------------------------------------------------

TTime CBTGPSFix::GsvTime() const

    {

    return iGsvTime;

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ParseMessage

// Fills the information available from a command to the fix

// -----------------------------------------------------------------------------

CBTGPSFix::TParsingStatus CBTGPSFix::ParseMessage(const TBTGPSNmeaParser& aParser)

    {

    TRACESTRING("CBTGPSFix::ParseMessage start...")

    TRAPD(err, ParseMessageL(aParser));

    TParsingStatus ret = EUnkown;

    switch(err)

        {

        case KErrNone:

            ret = EInfoUpdated;

            break;

        case KErrNotSupported:

            ret = EUnkown;

            break;

        default:

            ret = EInvalid;

        }

    TRACESTRING("CBTGPSFix::ParseMessage end")

    return ret;

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ParseMessageL

// Fills the information available from a command to the fix

// -----------------------------------------------------------------------------

void CBTGPSFix::ParseMessageL(const TBTGPSNmeaParser& aParser)

    {

    if(!aParser.IsValid())

        {

        User::Leave(KErrCorrupt);

        }

    switch (aParser.MessageId())

        {

        case ENmeaGPGSV: 

            ParseGSVSentenceL(aParser);

            break;

        case ENmeaGPRMC:

            ParseRMCSentenceL(aParser);

            break;

        case ENmeaGPGGA:

            ParseGGASentenceL(aParser);

            break;

        case ENmeaGPGSA:

            ParseGSASentenceL(aParser);

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ParseGGASentenceL

// 

// -----------------------------------------------------------------------------

void CBTGPSFix::ParseGGASentenceL(

        const TBTGPSNmeaParser& aParser)

    {

    GetLatitudeLongitude(aParser, ENmeaFieldGPGGALatitude);

    //Get GPS Quality indicator. 

    //By default, assume GPS works in normal mode

    TInt gpsQualityIndicator(EGpsQualitySPS); 

    if(aParser.GetFieldData(ENmeaFieldGPGGAFix, gpsQualityIndicator)==KErrNone)

        {

        //Get satellite mode

        switch(gpsQualityIndicator)

            {

            case EGpsQualityManualInput:

                iGpsMode = EGpsModeManualInput;

                break;

            case EGpsQualityNotValid:

                iGpsMode = EGpsModeInvalid;

                break;

            case EGpsQualityEstimated:

                iGpsMode = EGpsModeEstimated;

                break;

            case EGpsQualitySimulation:

                iGpsMode = EGpsModeSimulator;

                break;

            case EGpsQualitySPS:

            case EGpsQualityDGPS:

            case EGpsQualityPPS:

            case EGpsQualityRTK:

            case EGpsQualityFloatRTK:

            default:

                //Specify any value other than those defined in NMEA spec as 

                //Satellite mode. This will enable PSY working with mal-functioning

                //GPS and future GPS technology.

                iGpsMode = EGpsModeSatellite;

                break;

            }

        }

    //Get number of satellites in use

    aParser.GetFieldData(

        ENmeaFieldGPGGASatellitesUsed,

        iSatellitesUsed);

    //Get HDOP

    aParser.GetFieldData(

        ENmeaFieldGPGGAHDOP,

        iHorizontalDoP);

    //Acquire altitude over msl

    TReal tempVal32(0); 

    aParser.GetFieldData(

        ENmeaFieldGPGGAMSLAltitude,

        tempVal32);

    //Get Geoidal seperation

    aParser.GetFieldData(

        ENmeaFieldGPGGAGeoidalSeperation,

        iGeoidalSeperation);

    //Caculate altitude over WGS84

    iAltitude = tempVal32+iGeoidalSeperation;

    //GGA received

    iReceivedMsgMask = iReceivedMsgMask | EReceivedGGA; 

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ParseGSVSentenceL

// 

// -----------------------------------------------------------------------------

void CBTGPSFix::ParseGSVSentenceL(

        const TBTGPSNmeaParser& aParser)

    {

    //Get message number

    TInt messageNumber(1);

    User::LeaveIfError(aParser.GetFieldData(

        ENmeaFieldGPGSVMessageNumber,

        messageNumber));

    //Check validity of message number

    if(messageNumber>KMaxGSVMessageNumber)

        {

        User::Leave(KErrCorrupt);

        }

    if(messageNumber == 1)

        {

        //Get total number messages

        TInt totalNumberOfMessages(iGsvTotalNumberOfMessage);

        User::LeaveIfError(aParser.GetFieldData(

            ENmeaFieldGPGSVNumberOfMessage,

            totalNumberOfMessages));

        iGsvTotalNumberOfMessage = totalNumberOfMessages;

        //Get satellites in view

        TInt satellitesInView(iGsvSatelliteInView); 

        aParser.GetFieldData(

            ENmeaFieldGPGSVSatellitesInView,

            satellitesInView);

        iGsvSatelliteInView = satellitesInView;

        //Clear cache

        for(TInt i=0; i<KMaxGSVMessageNumber; i++)

            {

            iNMEAGSVCache[i].Zero();

            }

        }

    if(iGsvTotalNumberOfMessage == 0)

        {

        //Wait until we get the message number 1

        return;

        }

    //copy NMEA sentence to cache

    SecureCopy(iNMEAGSVCache[messageNumber-1], aParser.NmeaSentence());

    if(messageNumber == iGsvTotalNumberOfMessage)

        {

        //Extract satellite info from all the cached messages.

        iNumberOfSatellites = 0;

        iSatelliteArray.Reset();

        //Extract sat info from cache

        for(TInt i=0; i<iGsvTotalNumberOfMessage-1; i++)

            {

            TBTGPSNmeaParser cacheMsgParser;

            cacheMsgParser.SetNmeaSentence(iNMEAGSVCache[i]);

            if(cacheMsgParser.IsValid())

                {

                ExtractSatInfoL(cacheMsgParser);

                }

            }

        //Extract sat info from this message

        ExtractSatInfoL(aParser);

        //Reset total number of message and number of sat in view

        iGsvTotalNumberOfMessage = 0;

        iGsvSatelliteInView = 0;

        //Clear cache

        for(TInt i=0; i<KMaxGSVMessageNumber; i++)

            {

            iNMEAGSVCache[i].Zero();

            }

        //Set GSV time

        iGsvTime.UniversalTime();

        TRACESTRING2("CBTGPSFix:: Set GSV Time=%d", iGsvTime.Int64())

        }

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ExtractSatInfo

// 

// -----------------------------------------------------------------------------

void CBTGPSFix::ExtractSatInfoL(const TBTGPSNmeaParser& aParser)

    {

    //get message number

    TInt messageNumber(1);

    User::LeaveIfError(aParser.GetFieldData(

        ENmeaFieldGPGSVMessageNumber,

        messageNumber));

    //Detect the number of satellites in this message

    if( (((messageNumber - 1) * 4) + 1) <= iGsvSatelliteInView )

        {

        ExtractSatelliteDataL(aParser,

            ENmeaFieldGPGSVSatelliteID1,

            ENmeaFieldGPGSVElevation1,

            ENmeaFieldGPGSVAzimuth1,

            ENmeaFieldGPGSVSNR1);

        }            

    //Detect the number of satellites in this message

    if ( (((messageNumber - 1) * 4) + 2) <= iGsvSatelliteInView )

        {

        ExtractSatelliteDataL(aParser,

            ENmeaFieldGPGSVSatelliteID2,

            ENmeaFieldGPGSVElevation2,

            ENmeaFieldGPGSVAzimuth2,

            ENmeaFieldGPGSVSNR2);

        }            

    //Detect the number of satellites in this message

    if ( (((messageNumber - 1) * 4) + 3) <= iGsvSatelliteInView )

        {

        ExtractSatelliteDataL(aParser,

            ENmeaFieldGPGSVSatelliteID3,

            ENmeaFieldGPGSVElevation3,

            ENmeaFieldGPGSVAzimuth3,

            ENmeaFieldGPGSVSNR3);

        }            

    //Detect the number of satellites in this message

    if ( (((messageNumber - 1) * 4) + 4) <= iGsvSatelliteInView )

        {

        ExtractSatelliteDataL(aParser,

            ENmeaFieldGPGSVSatelliteID4,

            ENmeaFieldGPGSVElevation4,

            ENmeaFieldGPGSVAzimuth4,

            ENmeaFieldGPGSVSNR4);

        }            

    }

// -----------------------------------------------------------------------------

// CBTGPSFix::ParseGSASentenceL

// 

// -----------------------------------------------------------------------------

void CBTGPSFix::ParseGSASentenceL(

        const TBTGPSNmeaParser& aParser)

    {

    TInt err = KErrNone;

    // Acquire fix status

    TInt validity(CBTGPSFix::EFixValidityUnkown);

    aParser.GetFieldData(

        ENmeaFieldGPGSAMode2,

        validity);

    // 2D fix

    if ( 2 == validity )

        {

        iValid = CBTGPSFix::EFixValid2D;

        }

    // 3D fix

    else if ( 3 == validity )

        {

        iValid = CBTGPSFix::EFixValid3D;

        }

    // No fix

    else

        {

        iValid = CBTGPSFix::EFixNotValid;

        }   

    //Get number of used satellites

    iSatellitesUsed = 0;

    for ( TInt i = ENmeaFieldGPGSASatellitesUsedCH1; 

            i <= ENmeaFieldGPGSASatellitesUsedCH12; i++ )

        {

        TInt usedSatelliteId=0;

        err = aParser.GetFieldData(

            i,

            usedSatelliteId);

        if(err==KErrNone && usedSatelliteId !=0)

            {

            iUsedSatellitesArray[iSatellitesUsed] = usedSatelliteId;

            iSatellitesUsed++;

            }

        }

    //Get HDOP