// Copyright (c) 2005-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 "BTGPSRequestManager.h"

#include "BTGPSConnectManager.h"

#include "BTGPSConstantsManager.h"

#include "BTGPSRequestHandler.h"

#include "BTGPSFix.h"

#include "BTGPSNmeaBuffer.h"

#include "BTGPSNmeaParser.h"

#include "BTGPSLocationFixListener.h"

#include "BTGPSLogging.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

//GSV wait time. If GSV sentence is not available, system

//wait wait this much time before the fix is delivered.

const TInt KBTGPSGsvWaitTime = 1000000; //1 second

//NMEA sentence terminator

_LIT8(KBTGPSNmeaTerminator, "\x0d\x0a");

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CBTGPSRequestManager::NewL

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

CBTGPSRequestManager* CBTGPSRequestManager::NewL(

    CBTGPSConnectManager& aConnectManager,

    CBTGPSConstantsManager& aConstantsManager)

    {

    CBTGPSRequestManager* self = new (ELeave) CBTGPSRequestManager(

        aConnectManager,

        aConstantsManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CBTGPSRequestManager::~CBTGPSRequestManager

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

CBTGPSRequestManager::~CBTGPSRequestManager()

    {

    if(iTimer!=NULL)

        {

        iTimer->Cancel();

        delete iTimer;

        }

    delete iFix;

    delete iLastFix;

    iListenerArray.Close();

    delete iNmeaBuffer;

    }

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

// CBTGPSRequestManager::ConstructL

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

void CBTGPSRequestManager::ConstructL()

    {

    iNmeaBuffer = CBTGPSNmeaBuffer::NewL(

        iConstantsManager.iNmeaBufferSize);

    iFix = new (ELeave) CBTGPSFix();

    iFix->SetNmeaBuffer(iNmeaBuffer);

    iLastFix = new (ELeave) CBTGPSFix();

    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    }

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

// CBTGPSRequestManager::CBTGPSRequestManager

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

// might leave.

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

CBTGPSRequestManager::CBTGPSRequestManager(

    CBTGPSConnectManager& aConnectManager,

    CBTGPSConstantsManager& aConstantsManager)

    : iConnectManager(aConnectManager),

      iConstantsManager(aConstantsManager)

    {

    iPrevBottom = 0;

    }

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

// CBTGPSRequestManager::RetrieveFixL

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

void CBTGPSRequestManager::RetrieveFixL()

    {

    if(!iReceivingMessage)

        {

        iConnectManager.AddMessageListenerL(*this);

        iReceivingMessage = ETrue;

        }

    }

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

// CBTGPSRequestManager::StopRetrievingFix

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

void CBTGPSRequestManager::StopRetrievingFix()

    {

    //For better performance, system handles received message

    //when device is connected.

    }

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

// CBTGPSRequestManager::HandleMessage

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

void CBTGPSRequestManager::HandleMessage(const TBTGPSNmeaParser& aParser)

    {

    //Add the received message to buffer

    iNmeaBuffer->AddSentences(aParser.NmeaSentence());

    //Add 0x0d 0x0a

    iNmeaBuffer->AddSentences(KBTGPSNmeaTerminator);

    //Parse the message

    CBTGPSFix::TParsingStatus err = iFix->ParseMessage(aParser);

    //Check if we have received a valid sentence

    if(err == CBTGPSFix::EInfoUpdated)

        {

        if(iFix->IfFullNmeaPatternReceived())

            {

            TTime gsvTime = iFix->GsvTime();

            TTime now;

            now.UniversalTime();

            TRACESTRING2("CBTGPSRequestManager:: Now time = %d", now.Int64())

            TRACESTRING2("CBTGPSRequestManager:: GSV time = %d", gsvTime.Int64())

            if(gsvTime!=0 && now.MicroSecondsFrom(gsvTime)< 

                CBTGPSRequestHandler::ConstantsManager().iSatelliteInfoLifeTime)

                {

                //GSV information is still valid, set fix as valid

                TRACESTRING("CBTGPSRequestManager:: GSV information is still valid")

                iTimer->Cancel();

                InformListeners();

                }

            else

                {

                if(!iTimer->IsActive())

                    {

                    //GSV information is not valid, start timer

                    iTimer->Start(

                        KBTGPSGsvWaitTime,

                        KBTGPSGsvWaitTime,

                        TCallBack(TimerCallback, this));

                    }

                }

            }

        }

    }

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

// CBTGPSRequestManager::LastLocation

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

TInt CBTGPSRequestManager::LastLocation(

            const CBTGPSFix*& aFix,

            const TTime& aMaxAge,

            const TBool /*aAcceptPartial*/)

    {

    if(aMaxAge.Int64() == 0)

        {

        return KErrNotFound;

        }

    if(iLastFix->IsFixValid())

        {

        if(iLastFix->FixTime()>=aMaxAge)

            {

            aFix = iLastFix;

            return KErrNone;

            }

        }

    return KErrNotFound;

    }

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

// CBTGPSRequestManager::SystemTimeChange

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

void CBTGPSRequestManager::SystemTimeChange()

    {

    iLastFix->Reset();

    //Reset GSV time

    iFix->ResetGSVTime();

    }

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

// CBTGPSRequestManager::AddListenerL

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

void CBTGPSRequestManager::AddListenerL(MBTGPSLocationFixListener& aListener)

    {

    User::LeaveIfError(iListenerArray.Append(&aListener));

    }

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

// CBTGPSRequestManager::RemoveListener

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

void CBTGPSRequestManager::RemoveListener(MBTGPSLocationFixListener& aListener)

    {

    TInt index = iListenerArray.Find(&aListener);

    if(index!=KErrNotFound)

        {

        iListenerArray.Remove(index);

        }

    }

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

// CBTGPSRequestManager::InformListeners

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

void CBTGPSRequestManager::InformListeners()

    {

    TRACESTRING("CBTGPSRequestManager::InformListeners start...")

    //Inform listeners

    TInt count = iListenerArray.Count();

    for(TInt i=count-1; i>=0; i--)

        {

        iListenerArray[i]->HandleLocationFixUpdate(*iFix);

        }

    //If fix is valid then save it to last fix

    if(iFix->IsFixValid())

        {

        *iLastFix = *iFix;

        }

    //Reset fix after listeners are informed.

    iFix->ResetFix();

    //Set previous bottom of NMEA buffer

    iPrevBottom = iNmeaBuffer->CurrentIndex();

    TRACESTRING("CBTGPSRequestManager::InformListeners end")

    }

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

// CBTGPSRequestManager::GetPreviousNmeaBufferBottom

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

TInt CBTGPSRequestManager::GetPreviousNmeaBufferBottom() const

    {

    return iPrevBottom;

    }

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

// CBTGPSRequestManager::TimerTick

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

void CBTGPSRequestManager::TimerTick()

    {

    //Deliver fix even the satellite information is not valid

    TRACESTRING("CBTGPSRequestManager::TimerTick GSV information not valid")

    InformListeners();

    iTimer->Cancel();

    }

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

// CBTGPSRequestManager::TimerCallback

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

TInt CBTGPSRequestManager::TimerCallback(TAny* aAny)

    {

    reinterpret_cast<CBTGPSRequestManager*>(aAny)->TimerTick();

    return KErrNone; //Stop periodic timer

    }

//  End of File