// Copyright (c) 2007-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 <ecom/ecom.h>

#include <lbscommon.h>

#include <lbspositioninfo.h>

#include <lbs/epos_cposmodules.h>

#include <lbs/epos_cposmoduleidlist.h>

#include <lbs/epos_cpositioner.h>

#include <lbssatellite.h>

#include "epos_mposmodulestatusmanager.h"

#include "EPos_CPosRequestController.h"

#include "epos_cposrequestor.h"

#include "epos_defaultproxycommon.h"

#include "epos_cpospsylisthandler.h"

#include "epos_cpospsyfixstatemanager.h"

#include "epos_cposconstmanager.h"

#include "epos_cposexternalgpsmonitor.h"

#include "epos_posgenericinfouser.h"

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

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

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

// might leave.

//

CPosRequestController::CPosRequestController(

    CPosDefaultPositioner& aDefaultPositioner, 

    MPosModuleStatusManager& aModuleStatusManager)

    :

    iDefaultPositioner( aDefaultPositioner ),

    iModuleStatusManager( aModuleStatusManager ),

    iCurrentPsy( KErrNotFound )

    {

    }

// EPOC default constructor can leave.

void CPosRequestController::ConstructL(

        MPosModuleSettingsManager& aSettingsManager )

    {

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

    iPsyListHandler = CPosPsyListHandler::GetInstanceL();

    iPsyListHandler->SetModuleSettingsManagerL( 

        aSettingsManager );

    iPsyListHandler->AddListenerL( this );

    iPsyFixStateManager = CPosPsyFixStateManager::GetInstanceL();

    iPsyFixStateManager->AddListenerL( this );

    iConstManager = CPosConstManager::GetInstanceL();

    iExtGpsPsyMonitor = CPosExternalGpsMonitor::GetInstanceL( 

        iDefaultPositioner,

        iModuleStatusManager );

    //Construct cleanup timer

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

    TRACESTRING( "CPosRequestController::ConstructL end " )

    }

// Two-phased constructor.

CPosRequestController* CPosRequestController::NewL(

    CPosDefaultPositioner& aDefaultPositioner,

    MPosModuleSettingsManager& aSettingsManager,

    MPosModuleStatusManager& aModuleStatusManager )

    {

    CPosRequestController* self = new (ELeave)

        CPosRequestController(

            aDefaultPositioner,

            aModuleStatusManager );

    CleanupStack::PushL(self);

    self->ConstructL( 

        aSettingsManager );

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CPosRequestController::~CPosRequestController()

    {

    TRACESTRING( "CPosRequestController::destructor start... " )

    if ( iPsyFixStateManager )

        {

        iPsyFixStateManager->RemoveListener( this );

        iPsyFixStateManager->ReleaseInstance();

        }

    if ( iPsyListHandler )

        {

        iPsyListHandler->RemoveListener( this );

        iPsyListHandler->ReleaseInstance();

        }

    if ( iConstManager )

        {

        iConstManager->ReleaseInstance();

        }

    if ( iExtGpsPsyMonitor )

        {

        iExtGpsPsyMonitor->ReleaseInstance(

            iDefaultPositioner );

        }

    // Close all requestors 

    iRequestorArray.ResetAndDestroy();

    iRequestorArray.Close();

    //Close PSY List

    iPsyList.Close();

    // Cleanup timer

    delete iCleanupTimer;

    TRACESTRING( "CPosRequestController::destructor end... " )

    }

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

// CPosRequestController::NotifyPositionUpdate

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

//

void CPosRequestController::NotifyPositionUpdate(

    TPositionInfoBase& aPosInfo,

    TRequestStatus& aStatus)

    {

    TRACESTRING( "CPosRequestController::NotifyPositionUpdate start... " )

    //Default Proxy can't handle simultaneous location request.

    __ASSERT_DEBUG( 

        iPosRequestStatus == NULL, 

        DefaultProxyPanic( EDefaultProxyPanic_SimualtaneousLR ) );

    aStatus = KRequestPending;

    iPosRequestStatus = &aStatus;

    iPosInfo = &aPosInfo;

    //When location request received, clear cleanup timer

    iCleanupTimer->Cancel();

    TRAPD( err, StartPositionUpdateL() );

    if( err != KErrNone )

        {

        CompleteRequest(err);

        }

    TRACESTRING( "CPosRequestController::NotifyPositionUpdate end " )

    }

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

// CPosRequestController::CancelNotifyPositionUpdate

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

//

void CPosRequestController::CancelNotifyPositionUpdate(TInt aCancelReason)

    {

    TRACESTRING( "CPosRequestController::CancelNotifyPositionUpdate(TInt) start... " )

    //Cancel location request with error to all loaded requestor

    TInt loadedRequestorCount = iRequestorArray.Count();

    for ( TInt i = 0; i < loadedRequestorCount; i++ )

        {

        CancelRequest( i, aCancelReason );

        }

    CompleteRequest(KErrCancel);

    TRACESTRING( "CPosRequestController::CancelNotifyPositionUpdate(TInt) end " )

    }

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

// CPosRequestController::CancelNotifyPositionUpdate

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

//

void CPosRequestController::CancelNotifyPositionUpdate()

    {

    TRACESTRING( "CPosRequestController::CancelNotifyPositionUpdate start... " )

    // This is a real user cancel

    CancelNotifyPositionUpdate(KErrCancel);

    TRACESTRING( "CPosRequestController::CancelNotifyPositionUpdate end " )

    }

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

// CPosRequestController::CancelRequest

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

//

void CPosRequestController::CancelRequest( TInt aIndex, TInt aCancelReason )

    {

    TInt count = iRequestorArray.Count();

    if ( aIndex < count )

        {

        CPosRequestor* requestor = iRequestorArray[aIndex];

        if ( requestor->IsActive() )

            {

            //Notify external GPS PSY monitor that this PSY is not used.

            iExtGpsPsyMonitor->PsyNotUsed( requestor->ModuleId() );

            requestor->CancelWithReason(aCancelReason);

            }

        }

    }

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

// CPosRequestController::CancelRequest

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

//

void CPosRequestController::CancelRequest( TPositionModuleId aPsyId )

    {

    TInt count = iRequestorArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        CPosRequestor* requestor = iRequestorArray[i];

        if ( requestor->ModuleId() == aPsyId && 

            requestor->IsActive() )

            {

            //Notify external GPS PSY monitor that this PSY is not used.

            iExtGpsPsyMonitor->PsyNotUsed( requestor->ModuleId() );

            requestor->Cancel();

            }

        }

    }

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

// CPosRequestController::StartTrackingL

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

//

void CPosRequestController::StartTracking(

    const TTimeIntervalMicroSeconds& /*aInterval*/)

    {

    //This function does nothing. Tracking will be started

    //to any specific PSY only if this PSY will be used by

    //Default Proxy. 

    TRACESTRING( "CPosRequestController::StartTracking" )

    }

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

// CPosRequestController::StopTracking

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

//

void CPosRequestController::StopTracking()

    {

    TRACESTRING( "CPosRequestController::StopTracking start..." )

    //Stop tracking to all loaded PSYs

    TInt loadedRequestorCount = iRequestorArray.Count();

    for ( TInt i = 0; i < loadedRequestorCount; i++ )

        {

        iRequestorArray[i]->StopTracking();

        }

    TRACESTRING( "CPosRequestController::StopTracking end" )

    }

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

// CPosRequestController::StartPositionUpdateL

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

//

void CPosRequestController::StartPositionUpdateL()

    {

    TRACESTRING( "CPosRequestController::StartPositionUpdateL start..." )

    //Rebuid PSY list if neccessary

    if ( !iPsyListValid )

        {

        iPsyListHandler->GetPsyListL( iPsyList );

        iPsyListValid = ETrue;

        }

    iFirstResult = KErrNotFound;    // as if no enabled psys found

    iCurrentPsy = KErrNotFound;     // start from first module

    TryNextPositioner();

    if ( !IsLocationRequestOnGoing() )

        {

        CompleteRequest( iFirstResult );

        }

    TRACESTRING( "CPosRequestController::StartPositionUpdateL end" )

    }

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

// CPosRequestController::TryNextPositioner

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

//

void CPosRequestController::TryNextPositioner()

{

    TRACESTRING( "CPosRequestController::TryNextPositioner start..." )

    // Find next enabled plugin we should try with

    TInt count = iPsyList.Count();

    while ( ++iCurrentPsy < count )

        {

        TPositionModuleId currentPsyId = iPsyList[iCurrentPsy];

        TRACESTRING2( "PSY: %x", currentPsyId )

        TUint32 classType = iPosInfo->PositionClassType();

        if ( !iPsyListHandler->IsClassSupported( 

            classType,

            currentPsyId ) )

            {

            //if the requested class is not supported, then we try next PSY

            //in the PSY list

            if ( iCurrentPsy == 0 )

                {

                //Error code fromt the first PSY

                iFirstResult = KErrArgument;

                }

            continue;

            }

        TRAPD( err, TryPositionerL( currentPsyId ) );

        TRACESTRING2( "Try PSY completion code = %d", err )

        if( err == KErrNone )

            {

            //Location request is made to currentPsy. Check the fix state of

            //current PSY, if current PSY can't give a fix, we load next PSY

            if ( iPsyFixStateManager->GetPsyFixState( currentPsyId ) 

                != CPosPsyFixStateManager::EPsyFixStateNo )

                {

                //break from here. Othsewise, try next PSY

                break;

                }

            }

        else

            {

            //In error case, we store the error code if needed and try next PSY

            if ( iCurrentPsy == 0 )

                {

                //Error code fromt the first PSY

                iFirstResult = err;

                }

            }

        }

    TRACESTRING( "CPosRequestController::TryNextPositioner end" )

}

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

// CPosRequestController::TryPositionerL

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

//

void CPosRequestController::TryPositionerL( TPositionModuleId aPsyId )

    {

    CPosRequestor* currentRequestor = NULL;

    //Check device status of the PSY. If it's in error status,

    //it will not be used at all.

    TPositionModuleStatus moduleStatus;

    iModuleStatusManager.GetModuleStatus( 

        aPsyId,

        moduleStatus );

    if ( moduleStatus.DeviceStatus() == TPositionModuleStatus::EDeviceError )

        {

        TRACESTRING2( "PSY %x device error", aPsyId )

        User::Leave( KErrGeneral );

        }

    //Find if the PSY is already loaded

    TInt requestorCount = iRequestorArray.Count();

    for ( TInt i = 0; i < requestorCount; i++ )

        {

        if ( iRequestorArray[i]->ModuleId() == aPsyId )

            {

            currentRequestor = iRequestorArray[i];

            break;

            }

        }

    if ( currentRequestor == NULL )

        {

        //PSY has not been loaded before, load it now

        TRACESTRING2( "Loading Positioner: %x", aPsyId )

        currentRequestor = 

            CPosRequestor::NewL(

                iDefaultPositioner,

                aPsyId,

                *this,

                *iPsyFixStateManager,

                iModuleStatusManager );

        CleanupStack::PushL( currentRequestor );

        //Notify fix state manager that a PSY is loaded

        iPsyFixStateManager->PsyLoadedL( aPsyId );

        //Add this requestor to requestor array

        User::LeaveIfError( iRequestorArray.Append( 

            currentRequestor ) );

        CleanupStack::Pop( currentRequestor );

        }

    //Start tracking if needed

    TTimeIntervalMicroSeconds interval = iDefaultPositioner.TrackingInterval();

    if (interval.Int64() != 0 )

        {

        currentRequestor->StartTrackingL( interval );

        }

    //Make location request to current positioner

    currentRequestor->MakeLocationRequestL( *iPosInfo );

    //Notify external GPS PSY monitor that a PSY is used

    iExtGpsPsyMonitor->PsyUsed( aPsyId );

    }

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

// CPosRequestController::LocationRequestCompleted

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

//

void CPosRequestController::LocationRequestCompleted( 

            TPositionModuleId aModuleId,

            TInt aErr,

            const TPositionInfoBase& aPosInfo,

            TBool aIsPosInfoUpToDate )

    {

    TRACESTRING( "CPosRequestController::LocationRequestCompleted start..." )

    TRACESTRING2( "PSY: %x", aModuleId )

    TRACESTRING2( "Err: %d", aErr )

    TRACESTRING2( "Is PosInfo Updated: %d", aIsPosInfoUpToDate )

    //Notify the external GPS PSY monitor that a PSY in not used

    iExtGpsPsyMonitor->PsyNotUsed( aModuleId );

    TInt err = aErr;

    if ( aErr == KPositionPartialUpdate && IsLocationRequestOnGoingOnNetworkPsy() )

        {

        //Partial update is returned when Network PSY is used.

        //partial update is not forwarded to system. Instead, location

        //request is made to the loaded PSY again.

        TInt ignore;

        TRAP( ignore, TryPositionerL( aModuleId ) );

        }

    else if ( aErr == KErrNone || 

        aErr == KErrPositionBufferOverflow ||

        aErr == KPositionPartialUpdate  )

        {

        //Location request succeed or

        //buffer over flow is returned from a PSY or

        //partial update is returned when only GPS PSY is used

        //Copy request info, and complete LR

        if ( aIsPosInfoUpToDate )

            {

            __ASSERT_DEBUG( 

                aPosInfo.PositionClassSize() == iPosInfo->PositionClassSize(),

                DefaultProxyPanic( EDefaultProxyPanic_PosInfoSizeMismatch ) );

            Mem::Copy( iPosInfo, &aPosInfo, iPosInfo->PositionClassSize() );

            }

        else

            {

            TInt cpErr = CopyPosInfoClass( aPosInfo , *iPosInfo );

            if ( cpErr != KErrNone && err == KErrNone )

                {

                err = cpErr;

                }

            }

        if ( iPosInfo->ModuleId() != aModuleId )

            {

            err = KErrGeneral;

            }

        CompleteRequest( err );

        }

    else

        {

        if ( aModuleId == iPsyList[0] )

            {

            //Store the result from first PSY

            iFirstResult = aErr;

            //Store module ID of first positioner

            iPosInfo->SetModuleId( aModuleId );

            }

        }

    //This will cause the state change notification and generate fallback 

    //if it's a error case.

    iPsyFixStateManager->SetPsyFixState( aModuleId, aErr );

    if ( !IsLocationRequestOnGoing() )

        {

        CompleteRequest( iFirstResult );

        }

    TRACESTRING( "CPosRequestController::LocationRequestCompleted end" )

    }

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

// CPosRequestController::IsLocationRequestOnGoing