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

#include <lbserrors.h>

#include "BTGPSPanic.h"

#include "BTGPSRequestHandler.h"

#include "BTGPSConstantsManager.h"

#include "BTGPSSettingManager.h"

#include "BTGPSDeviceManager.h"

#include "BTGPSConnectManager.h"

#include "BTGPSMessageSender.h"

#include "BTGPSInitManager.h"

#include "BTGPSRequestManager.h"

#include "BTGPSPsyConnectionManager.h"

#include "BTGPSNokDeviceHandler.h"

#include "BTGPSEnvChangeHandler.h"

#include "BTGPSModuleStatusHandler.h"

#include "BTGPSPowerManager.h"

#include "BTGPSPositionerExt.h"

#include "BTGPSLogging.h"

#include "btgpsdevicelistmanager.h"

//  CONSTANTS

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

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

// CBTGPSRequestHandler::NewL

// Two-phased constructor.

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

//

CBTGPSRequestHandler* CBTGPSRequestHandler::NewL()

    {

    CBTGPSRequestHandler* self = new( ELeave ) CBTGPSRequestHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CBTGPSRequestHandler::CBTGPSRequestHandler

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

// might leave.

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

//

CBTGPSRequestHandler::CBTGPSRequestHandler()

    {

    }

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

// CBTGPSRequestHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBTGPSRequestHandler::ConstructL()

    {

    TRACESTRING("CBTGPSRequestHandler::ConstructL start...")

    //Construct Constants Mangaer

    iConstantsManager = CBTGPSConstantsManager::NewL();

    //Construct the Device List Manager

    iDeviceListManager = CBTGPSDeviceListManager::NewL();

    //Construct Setting Manager

    iSettingManager = CBTGPSSettingManager::NewL();

    //Construct BT Device Manager

    iDeviceManager = CBTGPSDeviceManager::NewL();

    iDeviceManager->AddListenerL(*this);

    //Construct connection manager

    iConnectManager = CBTGPSConnectManager::NewL(

        *iSettingManager,

        *iDeviceManager,

        *iConstantsManager,

        *iDeviceListManager);

    //Construct init manager

    iInitManager = CBTGPSInitManager::NewL(

        *iConnectManager,

        *iDeviceManager,

        *iSettingManager);

    //Construct request manager

    iRequestManager = CBTGPSRequestManager::NewL(

        *iConnectManager,

        *iConstantsManager);

    iRequestManager->AddListenerL(*this);

    //Construct PSY connection manager

    iPsyConnectionManager = CBTGPSPsyConnectionManager::NewL();

    //Construct Nok device handler

    iNokDeviceHandler = CBTGPSNokDeviceHandler::NewL(

        *iConnectManager,

        *iSettingManager,

        *iConstantsManager,

        *iDeviceManager,

        *iDeviceListManager);

    //Module status handler

    iModuleStatusHandler = CBTGPSModuleStatusHandler::NewL(

        *iPsyConnectionManager,

        *iDeviceManager,

        *iRequestManager);

    //Power manager

    iPowerManager = CBTGPSPowerManager::NewL(

        *iConnectManager,

        *iPsyConnectionManager,

        *iDeviceManager,

        *iConstantsManager);

    //Construct Environment change handler

    iEnvChangeHandler = CBTGPSEnvChangeHandler::NewL(*iRequestManager);

    TRACESTRING("CBTGPSRequestHandler::ConstructL end")

    }

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

// CBTGPSRequestHandler::~CBTGPSRequestHandler

// Destructor.

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

CBTGPSRequestHandler::~CBTGPSRequestHandler()

    {

    if(iDeviceManager != NULL)

        {

        iDeviceManager->RemoveListener(*this);

        }

    if(iRequestManager!=NULL)

        {

        iRequestManager->RemoveListener(*this);

        }

    delete iDeviceListManager;    

    delete iEnvChangeHandler;

    delete iPowerManager;

    delete iModuleStatusHandler;

    delete iNokDeviceHandler;

    delete iPsyConnectionManager;

    delete iRequestManager;

    delete iInitManager;

    delete iConnectManager;

    delete iDeviceManager;

    delete iSettingManager;

    delete iConstantsManager;

    Dll::SetTls(NULL);

    }

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

// CBTGPSRequestHandler::GetInstanceL

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

//

CBTGPSRequestHandler * CBTGPSRequestHandler::GetInstanceL()

    {

    //Have we loaded the request handler already

    if ( !Dll::Tls() ) 

        {

        CBTGPSRequestHandler * theHandler = CBTGPSRequestHandler::NewL();

        Dll::SetTls(theHandler);

        }

    return reinterpret_cast<CBTGPSRequestHandler*>(Dll::Tls());

    }

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

// CBTGPSRequestHandler::Instance

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

CBTGPSRequestHandler& CBTGPSRequestHandler::Instance()

    {

    if(!Dll::Tls())

        {

        Panic(EPanicSingletonNotConstructed);

        }

    return *(reinterpret_cast<CBTGPSRequestHandler*>(Dll::Tls()));

    }

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

// CBTGPSRequestHandler::ConstantsManager

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

CBTGPSConstantsManager& CBTGPSRequestHandler::ConstantsManager()

    {

    return *(Instance().iConstantsManager);

    }

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

// CBTGPSRequestHandler::AcquireLocation

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

void CBTGPSRequestHandler::AcquireLocation(MBTGPSPositionerExt* aPSY)

    {

    TRACESTRING("CBTGPSRequestHandler::AcquireLocation start...")

    //tries to acquire locaiton

    TRAPD(err, AcquireLocationL(aPSY));

    if(err!=KErrNone)

        {

        //Convert error code

        if(err == KErrCouldNotConnect)

            {

            err = KPositionQualityLoss;

            }

        //if function leaves, then complete request with error code

        CompleteRequest(*aPSY, err);

        }

    TRACESTRING("CBTGPSRequestHandler::AcquireLocation end")

    }

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

// CBTGPSRequestHandler::AcquireLocation

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

void CBTGPSRequestHandler::AcquireLocationL(MBTGPSPositionerExt* aPSY)

    {

    //Make location request to connection manager

    iPsyConnectionManager->AcquireLocation(aPSY);

    //Connect to GPS

    User::LeaveIfError(iConnectManager->Connecting());

    //Retrieve Fix

    iRequestManager->RetrieveFixL();

    }

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

// CBTGPSRequestHandler::CancelAcquireLocation

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

void CBTGPSRequestHandler::CancelAcquireLocation(

                                    MBTGPSPositionerExt* aPSY)

{

    TRACESTRING("CBTGPSRequestHandler::CancelAcquireLocation start...")

    //Cancel location request from connection manager

    iPsyConnectionManager->CancelAcquireLocation(aPSY);

    if(iPsyConnectionManager->LocationRequestCount() == 0)

        {

        //When no location request, stop retrieving fix

        iRequestManager->StopRetrievingFix();

        }

    TRACESTRING("CBTGPSRequestHandler::CancelAcquireLocation end")

}

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

// CBTGPSRequestHandler::RegisterPSYL

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

void CBTGPSRequestHandler::RegisterPSYL(MBTGPSPositionerExt* aPSY)

    {

    TRACESTRING("CBTGPSRequestHandler::RegisterPSYL start...")

    //Register the psy

    iPsyConnectionManager->RegisterPSYL(aPSY);

    //Reconnecting to GPS and try to recover from error states

    iConnectManager->Reconnecting();

    //Set NMEA index

    aPSY->SetInitialNmeaBufferBottom(

        iRequestManager->GetPreviousNmeaBufferBottom());

    TRACESTRING2("Initial NMEA Buffer Bottom: %d", 

        iRequestManager->GetPreviousNmeaBufferBottom());

    TRACESTRING("CBTGPSRequestHandler::RegisterPSYL end")

    }

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

// CBTGPSRequestHandler::UnregisterPSY

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

void CBTGPSRequestHandler::UnregisterPSY(MBTGPSPositionerExt* aPSY)

    {

    TRACESTRING("CBTGPSRequestHandler::UnregisterPSY start...")

    //Unregister PSY

    iPsyConnectionManager->UnregisterPSY(aPSY);

    //If no PSY is connected, then delete this instance

    if ( iPsyConnectionManager->Count() == 0 )

        {

        //Report device status before destruction

        TPositionModuleStatus moduleStatus;

        moduleStatus.SetDataQualityStatus(TPositionModuleStatus::EDataQualityUnknown);

        moduleStatus.SetDeviceStatus(TPositionModuleStatus::EDeviceInactive);

        aPSY->ReportStatus(moduleStatus);

        delete this;

        }

    TRACESTRING("CBTGPSRequestHandler::UnregisterPSY end")

    }

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

// CBTGPSRequestHandler::TrackingSessionStart

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

void CBTGPSRequestHandler::TrackingSessionStartL(

    MBTGPSPositionerExt* aPSY,

    const TTimeIntervalMicroSeconds& aInterval)

    {

    TRACESTRING("CBTGPSRequestHandler::TrackingSessionStartL start...")

    iPsyConnectionManager->TrackingSessionStartL(aPSY, aInterval);

    TRACESTRING("CBTGPSRequestHandler::TrackingSessionStartL end")

    }

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

// CBTGPSRequestHandler::TrackingSessionStop

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

void CBTGPSRequestHandler::TrackingSessionStop(

                                    MBTGPSPositionerExt* aPSY)

    {

    TRACESTRING("CBTGPSRequestHandler::TrackingSessionStop start...")

    iPsyConnectionManager->TrackingSessionStop(aPSY);

    TRACESTRING("CBTGPSRequestHandler::TrackingSessionStop end")

    }

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

// CBTGPSRequestHandler::LastLocation

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

TInt CBTGPSRequestHandler::LastLocation(

                                         const CBTGPSFix*& aFix,

                                         const TTime& aMaxAge,

                                         const TBool aAcceptPartial)

    {

    return iRequestManager->LastLocation(aFix, aMaxAge, aAcceptPartial);

    }

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

// CBTGPSRequestHandler::CompleteRequest

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

void CBTGPSRequestHandler::CompleteRequest(

            MBTGPSPositionerExt& aPSY, 

            TInt aErr)

    {

    iPsyConnectionManager->CompleteRequest(aPSY, aErr);

    }

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

// CBTGPSRequestHandler::CompleteAllRequests

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

void CBTGPSRequestHandler::CompleteAllRequests(TInt aErr)

    {

    iPsyConnectionManager->CompleteAllRequests(aErr);

    }

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

// CBTGPSRequestHandler::HandleLocationFixAvailable

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

//

void CBTGPSRequestHandler::HandleLocationFixUpdate(const CBTGPSFix& aFix)

    {

    iPsyConnectionManager->LocationFixUpdate(aFix);

    if(iPsyConnectionManager->LocationRequestCount() == 0)

        {

        //If no location request, then stop retrieving fix

        iRequestManager->StopRetrievingFix();

        }

    }

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

// CBTGPSRequestHandler::BTDeviceStatusChanged

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

void CBTGPSRequestHandler::BTDeviceStatusChanged(

            TInt aConnectStatus, 

            TInt /*aDeviceType*/,

            TInt aErr)

    {

    if(aConnectStatus==EBTDeviceConnectError || 

        aConnectStatus == EBTDeviceDisconnected )

        {

        //When connect error or disconnected, then we complete all 

        //request with error KErrQualityLoss

        if(aErr!=KErrNoMemory)

            {

            aErr = KPositionQualityLoss;

            }

        CompleteAllRequests(aErr);

        }

    }

//  End of File