// 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 <lbscommon.h>

#include "BTGPSModuleStatusHandler.h"

#include "BTGPSPsyConnectionManager.h"

#include "BTGPSDeviceManager.h"

#include "BTGPSRequestManager.h"

#include "BTGPSFix.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CBTGPSModuleStatusHandler::NewL

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

CBTGPSModuleStatusHandler* CBTGPSModuleStatusHandler::NewL(

            CBTGPSPsyConnectionManager& aPsyConnectionManager,

            CBTGPSDeviceManager& aDeviceManager,

            CBTGPSRequestManager& aRequestManager)

    {

    CBTGPSModuleStatusHandler* self = new (ELeave) CBTGPSModuleStatusHandler(

        aPsyConnectionManager,

        aDeviceManager,

        aRequestManager);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CBTGPSModuleStatusHandler::~CBTGPSModuleStatusHandler

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

CBTGPSModuleStatusHandler::~CBTGPSModuleStatusHandler()

    {

    iPsyConnectionManager.RemoveListener(*this);

    iRequestManager.RemoveListener(*this);

    iDeviceManager.RemoveListener(*this);

    }

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

// CBTGPSModuleStatusHandler::ConstructL

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

void CBTGPSModuleStatusHandler::ConstructL()

    {

    iDeviceManager.AddListenerL(*this);

    iRequestManager.AddListenerL(*this);

    iPsyConnectionManager.AddListenerL(*this);

    //Set moudle status to not found

    iModuleStatus.SetDataQualityStatus(TPositionModuleStatus::EDataQualityLoss);

    iModuleStatus.SetDeviceStatus(TPositionModuleStatus::EDeviceUnknown);

    }

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

// CBTGPSModuleStatusHandler::CBTGPSModuleStatusHandler

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

// might leave.

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

CBTGPSModuleStatusHandler::CBTGPSModuleStatusHandler(

            CBTGPSPsyConnectionManager& aPsyConnectionManager,

            CBTGPSDeviceManager& aDeviceManager,

            CBTGPSRequestManager& aRequestManager)

    : iPsyConnectionManager(aPsyConnectionManager),

      iDeviceManager(aDeviceManager),

      iRequestManager(aRequestManager)

    {

    }

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

// CBTGPSModuleStatusHandler::HandlePsyConnectionChange

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

void CBTGPSModuleStatusHandler::HandlePsyConnectionChange()

    {

    TPositionModuleStatus::TDeviceStatus deviceStatus = GetDeviceStatus();

    if(deviceStatus!=iModuleStatus.DeviceStatus())

        {

        iModuleStatus.SetDeviceStatus(deviceStatus);

        iPsyConnectionManager.ReportStatus(iModuleStatus);

        }

    }

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

// CBTGPSModuleStatusHandler::BTDeviceStatusChanged

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

void CBTGPSModuleStatusHandler::BTDeviceStatusChanged(

            TInt aConnectStatus, 

            TInt aDeviceType,

            TInt /*aErr*/)

    {

    //Check if device initialising procedure is completed

    if(!iInitialized && 

        (aDeviceType == EBTDeviceTypeNonNokGps || aDeviceType == EBTDeviceTypeNokGps))

        {

        iInitialized = ETrue;

        }

    //Check device status

    TPositionModuleStatus::TDeviceStatus deviceStatus = GetDeviceStatus();

    //Check data quality

    TPositionModuleStatus::TDataQualityStatus dataQualityStatus = 

        iModuleStatus.DataQualityStatus();

    if(!(aConnectStatus == EBTDeviceConnected &&

        aDeviceType == EBTDeviceTypeNonNokGps || aDeviceType == EBTDeviceTypeNokGps))

        {

        dataQualityStatus =TPositionModuleStatus::EDataQualityLoss;

        }

    if(dataQualityStatus != iModuleStatus.DataQualityStatus() || 

        deviceStatus != iModuleStatus.DeviceStatus())

        {

        iModuleStatus.SetDataQualityStatus(dataQualityStatus);

        iModuleStatus.SetDeviceStatus(deviceStatus);

        iPsyConnectionManager.ReportStatus(iModuleStatus);

        }

    }

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

// CBTGPSModuleStatusHandler::HandleLocationFixUpdate

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

void CBTGPSModuleStatusHandler::HandleLocationFixUpdate(

            const CBTGPSFix& aFix)

    {

    if(!aFix.IfFullNmeaPatternReceived())

        {

        //if not full nmea pattern received, then not update data quality change

        return;

        }

    TPositionModuleStatus::TDataQualityStatus dataQualityStatus

        = TPositionModuleStatus::EDataQualityLoss;

    switch(aFix.FixState())

        {

        case CBTGPSFix::EFixValid2D:

            dataQualityStatus = TPositionModuleStatus::EDataQualityPartial;

            break;

        case CBTGPSFix::EFixValid3D:

            dataQualityStatus = TPositionModuleStatus::EDataQualityNormal;

            break;

        case CBTGPSFix::EFixNotValid:

            dataQualityStatus = TPositionModuleStatus::EDataQualityLoss;

            break;

        case CBTGPSFix::EFixValidityUnkown:

        default:

            //do nithing

            break;

        }

    if(dataQualityStatus != iModuleStatus.DataQualityStatus())

        {

        iModuleStatus.SetDataQualityStatus(dataQualityStatus);

        iPsyConnectionManager.ReportStatus(iModuleStatus);

        }

    }

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

// CBTGPSModuleStatusHandler::GetDeviceStatus

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

TPositionModuleStatus::TDeviceStatus CBTGPSModuleStatusHandler::GetDeviceStatus()

    {

    TPositionModuleStatus::TDeviceStatus deviceStatus = 

        TPositionModuleStatus::EDeviceUnknown;

    TInt connectStatus = iDeviceManager.DeviceConnectStatus();

    TInt deviceType = iDeviceManager.DeviceType();

    if(!iInitialized)

        {

        if(connectStatus == EBTDeviceConnectError)

            {

            //in error case, this will not change 

            //device status.

            deviceStatus = TPositionModuleStatus::EDeviceError;

            }

        else

            {

            deviceStatus = TPositionModuleStatus::EDeviceInitialising;

            }

        }

    else

        {

        switch (connectStatus)

            {

            case EBTDeviceDisconnected:

            case EBTDeviceConnecting:

            case EBTDeviceConnectError:

                deviceStatus = TPositionModuleStatus::EDeviceStandBy;

                break;

            case EBTDeviceConnected:

                if(iPsyConnectionManager.LocationRequestCount()>0 || 

                    iPsyConnectionManager.TrackingSessionCount()>0)

                    {

                    deviceStatus = TPositionModuleStatus::EDeviceActive;

                    }

                else

                    {

                    deviceStatus = TPositionModuleStatus::EDeviceReady;

                    }

                break;

            default:

                break;

            }

        }

    return deviceStatus;

    }

//  End of File