// 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 "BTGPSNmeaParser.h"

#include "BTGPSMessageDef.h"

#include "BTGPSPanic.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

//NMEA sentence field delimiter

const TUint8 KNmeaFieldDelimiter = ',';

//NMEA sentecne checksum delimiter

const TUint8 KNmeaChecksumDelimiter = '*';

//Data start postion of NMEA sentence

const TInt KNmeaDataStartPos = 1; 

//Minimum length of NMEA sentence(starter and check sum)

const TInt KNmeaMininumLength = 4;

//Checksum field length

const TInt KNmeaChecksumFieldLength = 2;

//Maximum length of address field length

const TInt KNmeaMaxAddressFieldLength = 32;

//Decimal seperator

const TUint8 KDecimalSeperator = '.';

/** 

* Structure for address field Id map

*/

struct TAddressFieldMessageIdMap

    {

    TText8 iField[KNmeaMaxAddressFieldLength];  //Field text

    TInt iId;                                   //Field id

    };

/**

* NMEA and Sirf specific NMEA sentence sId field text and 

* id mapping defination

*/

const struct TAddressFieldMessageIdMap KNmeaAddressIdMap[]=

    {

        {"GPGSV", ENmeaGPGSV},

        {"GPGLL", ENmeaGPGLL},

        {"GPRMC", ENmeaGPRMC},

        {"GPVTG", ENmeaGPVTG},

        {"GPGGA", ENmeaGPGGA},

        {"GPGSA", ENmeaGPGSA},

        {"PSRF107", ENmeaPSRF107},

        {"PSRF103", ENmeaPSRF103},

        {"PSRF101", ENmeaPSRF101},

        {"PSRF105", ENmeaPSRF105},

        {"PSRF201", ENmeaPSRF201},

        {"PNOK",    ENmeaProprietaryNok}

    };

/**

* PNOK message id field text and id mapping defination

*/

const struct TAddressFieldMessageIdMap KNmeaPNokAddressIdMap[]=

    {

        {"OK",          ENmeaPNokOk},

        {"RESET",       ENmeaPNokReset},

        {"MSGS",        ENmeaPNokPeriodicMsgs},

        {"LOWPWR",      ENmeaPNokLowPwrMode},

        {"NIGHTMODE",   ENmeaPNokNightMode},

        {"VER",         ENmeaPNokVersionInfo},

        {"STAT",        ENmeaPNokPeriodicEvents},

        {"TIME",        ENmeaPNokReferenceTime}

     };

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// TBTGPSNmeaParser::TBTGPSNmeaParser

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

TBTGPSNmeaParser::TBTGPSNmeaParser() : TDelimitedParserBase8()

    {

    SetDelimiter(KNmeaFieldDelimiter);

    }

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

// TBTGPSNmeaParser::SetNmeaSentence

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

void TBTGPSNmeaParser::SetNmeaSentence(const TDesC8& aNmea)

    {

    iNmea.Set(aNmea);

    iId = ENmeaNull;

    if(CheckValidity())

        {

        Parse(TrimSentence());

        GetMessageId();

        }

    }

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

// TBTGPSNmeaParser::NmeaSentence

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

const TDesC8& TBTGPSNmeaParser::NmeaSentence() const

    {

    return iNmea;

    }

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

// TBTGPSNmeaParser::IsValid

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

TBool TBTGPSNmeaParser::IsValid() const

    {

    return iId!=ENmeaNull;

    }

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

// TBTGPSNmeaParser::MessageId

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

TInt TBTGPSNmeaParser::MessageId() const

    {

    return iId;

    }

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

// TBTGPSNmeaParser::GetMessageId

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

void TBTGPSNmeaParser::GetMessageId()

    {

    iId = ENmeaUnknown;

    Reset();

    TPtrC8 address;

    if(GetFieldBlock(ENmeaFieldAddressField,address)==KErrNone)

        {

        for(TInt i=0; 

            i<sizeof(KNmeaAddressIdMap)/sizeof(TAddressFieldMessageIdMap);i++)

            {

            TPtrC8 knownAddress(KNmeaAddressIdMap[i].iField);

            if(address.Compare(knownAddress)==KErrNone)

                {

                TInt messageId = KNmeaAddressIdMap[i].iId;

                //If message if Nokia proprietary message, we have to check next field

                if(messageId == ENmeaProprietaryNok)

                    {

                    Reset();

                    Inc();Inc();

                    if(GetNext(address)==KErrNone)

                        {

                        for(TInt j=0; 

                            j<sizeof(KNmeaPNokAddressIdMap)/sizeof(TAddressFieldMessageIdMap); 

                            j++)

                            {

                            TPtrC8 nokAddress(KNmeaPNokAddressIdMap[j].iField);

                            if(address.Compare(nokAddress)==KErrNone)

                                {

                                iId = KNmeaPNokAddressIdMap[j].iId;

                                return;

                                }

                            }

                        }

                    }

                iId = messageId;

                return;

                }

            }

        }

    }

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

// TBTGPSNmeaParser::GetFieldBlock

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

TInt TBTGPSNmeaParser::GetFieldBlock(TInt aFieldId, TPtrC8& aField) const

    {

    Reset();

    if(aFieldId != ENmeaFieldAddressField)

        {

        TInt messageId = MessageId();

        //Check fieldId matches message Id

        if(aFieldId<messageId || aFieldId>=messageId+KNmeaMessageIdSkip)

            {

            return KErrNotFound;

            }

        //Skip address field and other fields

        if(messageId != ENmeaNull)

            {

            for(TInt i=0; i<aFieldId-messageId+2; i++)

                {

                Inc();

                }

            }

        }

    return GetNext(aField);

    }

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

// TBTGPSNmeaParser::IsNullField

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

TBool TBTGPSNmeaParser::IsNullField(TInt aFieldId) const

    {

    TPtrC8 fieldBlock;

    if(GetFieldBlock(aFieldId, fieldBlock)==KErrNone)

        {

        return fieldBlock.Length()==0;

        }

    //error case

    return ETrue;

    }

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

// TBTGPSNmeaParser::GetFieldData

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

template  <>

TInt TBTGPSNmeaParser::GetFieldData<TReal32>(TInt aFieldId, TReal32& aData) const

    {

    TPtrC8 fieldBlock;

    TInt err = GetFieldBlock(aFieldId, fieldBlock);

    if(err==KErrNone && fieldBlock.Length()>0)

        {

        TLex8 lex(fieldBlock);

        return lex.Val(aData, KDecimalSeperator);

        }

    return err;

    }

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

// TBTGPSNmeaParser::GetFieldData

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

template  <>

TInt TBTGPSNmeaParser::GetFieldData<TReal>(TInt aFieldId, TReal& aData) const

    {

    TPtrC8 fieldBlock;

    TInt err = GetFieldBlock(aFieldId, fieldBlock);

    if(err==KErrNone && fieldBlock.Length()>0)

        {

        TLex8 lex(fieldBlock);

        return lex.Val(aData, KDecimalSeperator);

        }

    return err;

    }

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

// TBTGPSNmeaParser::GetFieldData

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

template  <>

TInt TBTGPSNmeaParser::GetFieldData<TInt>(TInt aFieldId, TInt& aData) const

    {

    TPtrC8 fieldBlock;

    TInt err = GetFieldBlock(aFieldId, fieldBlock);

    if(err==KErrNone && fieldBlock.Length()>0)

        {

        TLex8 lex(fieldBlock);

        return lex.Val(aData);

        }

    return err;

    }

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

// TBTGPSNmeaParser::GetFieldData<TInt>

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

#define GetFieldDataImplementation(s) \

template <> TInt TBTGPSNmeaParser::GetFieldData<s>(TInt aFieldId, s& aData) const \

    { \

    TPtrC8 fieldBlock; \

    TInt err = GetFieldBlock(aFieldId, fieldBlock); \

    if(err==KErrNone && fieldBlock.Length()>0) \

        { \

        TLex8 lex(fieldBlock); \

        return lex.Val(aData); \

        } \

    return err; \

    }

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

// TBTGPSNmeaParser::NextFieldData

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

template <class T>

TInt TBTGPSNmeaParser::NextFieldData(T& aData) const

    {

    //This function must be called when the sentence is valid

    __ASSERT_DEBUG(IsValid(), Panic(EPanicInvalidNmeaSentence));

    TBuf8<KNmeaMaxAddressFieldLength> fieldBuf;

    TPtrC8 fieldBlock(fieldBuf);

    TInt err = GetNext(fieldBlock);

    if(err==KErrNone)

        {

        TLex8 lex(fieldBlock);

        return lex.Val(aData);

        }

    return err;

    }

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

// TBTGPSNmeaParser::CheckValidity

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

TBool TBTGPSNmeaParser::CheckValidity() const

    {

    TInt length = iNmea.Length();

    //Check the length of the NMEA sentence

    if(length<KNmeaMininumLength)

        {

        return EFalse;

        }

    //Check checksum

    TInt checksumDelimiterPos = iNmea.LocateReverse(KNmeaChecksumDelimiter);

    if((checksumDelimiterPos == KErrNotFound) || (checksumDelimiterPos + KNmeaChecksumFieldLength > length))

        {

        return EFalse;

        }

    //Get checsum field

    TLex8 lex(iNmea.Mid(checksumDelimiterPos, KNmeaChecksumFieldLength));

    //Check checksum 

    return VerifyChecksum(iNmea);

    }

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

// TBTGPSNmeaParser::TrimSentence

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

const TPtrC8 TBTGPSNmeaParser::TrimSentence() const

    {

    //Check checksum

    TInt checksumDelimiterPos = iNmea.LocateReverse(KNmeaChecksumDelimiter);

    return iNmea.Mid(

        KNmeaDataStartPos,

        checksumDelimiterPos-KNmeaDataStartPos);

    }

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

// TBTGPSNmeaParser::VerifyChecksum

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

//

TBool TBTGPSNmeaParser::VerifyChecksum(const TDesC8& aSentence) const

    {

    TUint8 checksum = 0;

    TInt i;

    TInt length = aSentence.Length();

    for (i = KNmeaDataStartPos; 

        i < length && aSentence[i] != KNmeaChecksumDelimiter; i++)

        {

        checksum ^= aSentence[i];

        }

    if (++i + KNmeaDataStartPos < aSentence.Length())

        {

        TUint8 sum = TUint8((CharToNibble(aSentence[i]) << 4) +

            CharToNibble(aSentence[i+1]));

        if (sum == checksum)

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// TBTGPSNmeaParser::CharToNibble

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

//

TUint8 TBTGPSNmeaParser::CharToNibble(const TUint8 aChar) const

    {

    if (aChar <= '9')

        {

        return TUint8(aChar - '0');

        }

    else

        {

        return TUint8(aChar - 'A' + 10);

        }

    }

//  End of File