// 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 "BTGPSPsyConnectionManager.h"
#include "BTGPSPositionerExt.h"
#include "BTGPSPsyConnectionListener.h"
#include "BTGPSPanic.h"
#include "BTGPSLogging.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// Undefined tracking interval
const TInt KTrackingIntervalUndefined = -1;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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


// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::NewL
// -----------------------------------------------------------------------------
CBTGPSPsyConnectionManager* CBTGPSPsyConnectionManager::NewL()
    {
    CBTGPSPsyConnectionManager* self = new (ELeave) CBTGPSPsyConnectionManager();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::~CBTGPSPsyConnectionManager
// -----------------------------------------------------------------------------
CBTGPSPsyConnectionManager::~CBTGPSPsyConnectionManager()
    {
    iPsyArray.Close();
    iListenerArray.Close();
    }


// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::ConstructL
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::CBTGPSPsyConnectionManager
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
CBTGPSPsyConnectionManager::CBTGPSPsyConnectionManager()
    {
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::RegisterPSYL
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::RegisterPSYL(MBTGPSPositionerExt* aPSY)
    {
    TRACESTRING("CBTGPSPsyConnectionManager::RegisterPSYL start...")
    //Construct PSY status
    TPSYStatusStruct psyStatus;
    psyStatus.iPsy = aPSY;
    psyStatus.iLocationRequest = EFalse;
    psyStatus.iTrackingInterval = KTrackingIntervalUndefined;
    
    //Location FW garentee that PSY can't be registered more than once
    
    //Add psy status to array
    User::LeaveIfError(iPsyArray.Append(psyStatus));
    InformListenersChange();
    TRACESTRING("CBTGPSPsyConnectionManager::RegisterPSYL end")
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::UnregisterPSY
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::UnregisterPSY(MBTGPSPositionerExt* aPSY)
    {
    TRACESTRING("CBTGPSPsyConnectionManager::UnregisterPSY start...")
    TInt index = FindPsy(aPSY);
    __ASSERT_DEBUG(index!=KErrNotFound, Panic(EPanicIndexOutOfRange));
    if(index!=KErrNotFound)
        {
        iPsyArray.Remove(index);
        InformListenersChange();
        }
    TRACESTRING("CBTGPSPsyConnectionManager::UnregisterPSY end")
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::AcquireLocation
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::AcquireLocation(MBTGPSPositionerExt* aPSY)
    {
    TInt index = FindPsy(aPSY);
    __ASSERT_DEBUG(index!=KErrNotFound, Panic(EPanicIndexOutOfRange));
    if(index!=KErrNotFound)
        {
        iPsyArray[index].iLocationRequest = ETrue;
        InformListenersChange();
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::CancelAcquireLocation
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::CancelAcquireLocation(MBTGPSPositionerExt* aPSY)
    {
    TInt index = FindPsy(aPSY);
    __ASSERT_DEBUG(index!=KErrNotFound, Panic(EPanicIndexOutOfRange));
    if(index!=KErrNotFound)
        {
        iPsyArray[index].iLocationRequest = EFalse;
        InformListenersChange();
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::CompleteRequest
// -----------------------------------------------------------------------------

void CBTGPSPsyConnectionManager::CompleteRequest(
            MBTGPSPositionerExt& aPSY,
            TInt aErr)
    {
    TRACESTRING("CBTGPSPsyConnectionManager::CompleteRequest start...")
    TInt index = FindPsy(&aPSY);
    __ASSERT_DEBUG(index!=KErrNotFound, Panic(EPanicIndexOutOfRange));
    if(index!=KErrNotFound)
        {
        CompleteLocationRequest(index, NULL, aErr);
        }
    TRACESTRING("CBTGPSPsyConnectionManager::CompleteRequest end")
    }
// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::CompleteAllRequests
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::CompleteAllRequests(TInt aErr)
    {
    TInt count = iPsyArray.Count();
    for(TInt i=0; i<count; i++)
        {
        CompleteLocationRequest(i, NULL, aErr);
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::LocationFixUpdate
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::LocationFixUpdate(const CBTGPSFix& aFix)
    {
    TInt count = iPsyArray.Count();
    for(TInt i=0; i<count; i++)
        {
        CompleteLocationRequest(i,&aFix, KErrNone);
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::Count
// -----------------------------------------------------------------------------
TInt CBTGPSPsyConnectionManager::Count() const
    {
    return iPsyArray.Count();
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::LocationRequestCount
// -----------------------------------------------------------------------------
TInt CBTGPSPsyConnectionManager::LocationRequestCount() const
    {
    TInt count = iPsyArray.Count();
    TInt locationReqCount = 0;
    for(TInt i=0; i<count; i++)
        {
        if(iPsyArray[i].iLocationRequest)
            {
            locationReqCount++;
            }
        }
    return locationReqCount;
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::TrackingSessionCount
// -----------------------------------------------------------------------------
TInt CBTGPSPsyConnectionManager::TrackingSessionCount() const
    {
    TInt count = iPsyArray.Count();
    TInt trackingCount = 0;
    for(TInt i=0; i<count; i++)
        {
        if(iPsyArray[i].iTrackingInterval>0)
            {
            trackingCount++;
            }
        }
    return trackingCount;
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::TrackingSessionStartL
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::TrackingSessionStartL(
            MBTGPSPositionerExt* aPSY,
            TTimeIntervalMicroSeconds aInterval)
    {
    TInt index = FindPsy(aPSY);
    __ASSERT_DEBUG(index!=KErrNotFound, Panic(EPanicIndexOutOfRange));
    if(index!=KErrNotFound && aInterval > 0)
        {
        iPsyArray[index].iTrackingInterval = aInterval;
        InformListenersChange();
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::TrackingSessionStop
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::TrackingSessionStop(MBTGPSPositionerExt* aPSY)
    {
    TInt index = FindPsy(aPSY);
    if(index!=KErrNotFound)
        {
        iPsyArray[index].iTrackingInterval = KTrackingIntervalUndefined;
        InformListenersChange();
        }
    }
    
// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::FindPsy
// -----------------------------------------------------------------------------
TInt CBTGPSPsyConnectionManager::FindPsy(MBTGPSPositionerExt* aPSY)
    {
    TInt count = iPsyArray.Count();
    for(TInt i=0; i<count; i++)
        {
        if(iPsyArray[i].iPsy == aPSY)
            {
            return i;
            }
        }
    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::CompleteLocationRequest
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::CompleteLocationRequest(
            TInt aIndex,
            const CBTGPSFix* aFix,
            TInt aErr)
    {
    if(iPsyArray[aIndex].iLocationRequest)
        {
        TBool completed = iPsyArray[aIndex].iPsy->RequestCompleteNotify(aFix, aErr);
        if(completed)
            {
            iPsyArray[aIndex].iLocationRequest = EFalse;
            InformListenersChange();
            }
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::ReportStatus
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::ReportStatus(const TPositionModuleStatus& aStatus)
    {
    TRACESTRING("CBTGPSPsyConnectionManager::ReportStatus start...")
    TRACESTRING2("DeviceStatus=%d", aStatus.DeviceStatus())
    TRACESTRING2("DataQuality =%d", aStatus.DataQualityStatus())

    //Report status from one PSY connection only
    if(iPsyArray.Count()>0)
        {
        iPsyArray[0].iPsy->ReportStatus(aStatus);
        }

    TRACESTRING("CBTGPSPsyConnectionManager::ReportStatus end")

    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::AddListenerL
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::AddListenerL(MBTGPSPsyConnectionListener& aListener)
    {
    User::LeaveIfError(iListenerArray.Append(&aListener));
    }
        
// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::RemoveListener
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::RemoveListener(MBTGPSPsyConnectionListener& aListener)
    {
    TInt index = iListenerArray.Find(&aListener);
    if(index!=KErrNotFound)
        {
        iListenerArray.Remove(index);
        }
    }

// -----------------------------------------------------------------------------
// CBTGPSPsyConnectionManager::InformListenersChange
// -----------------------------------------------------------------------------
void CBTGPSPsyConnectionManager::InformListenersChange()
    {
    TInt count = iListenerArray.Count();
    for(TInt i=count-1; i>=0; i--)
        {
        iListenerArray[i]->HandlePsyConnectionChange();
        }
    }

//  End of File