// 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 <e32base.h>
#include <lbs/epos_mpositionerstatus.h>
#include <ecom/implementationproxy.h>
#include <lbssatellite.h>

#include "BTGPSPositioner.h"
#include "BTGPSRequestHandler.h"
#include "BTGPSPanic.h"
#include "btgpspsy.hrh"
#include "BTGPSLogging.h"
#include "BTGPSNmeaBuffer.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS
static const TImplementationProxy KFactoryPtr = 
IMPLEMENTATION_PROXY_ENTRY( KPosBTPSYImplUid, CBTGPSPositioner::NewL);

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

/**
*  The extension class for the CBTGPSPositioner
*  Stores the instance variables
*/
class TBTGPSExtension
    {
    public:
        /**
        * default constructor
        */
        TBTGPSExtension():
            iRequestHandler(NULL),
            iActive(EFalse),
            iPosInfo(NULL),
            iStatus(NULL)
            {
            }

        //Pointer to the request handler
        CBTGPSRequestHandler* iRequestHandler;

        //Is there request pending
        TBool iActive;

        //Pointer to the current position info
        TPositionInfoBase* iPosInfo;

        //Pointer to the current request status
        TRequestStatus* iStatus;
    };

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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


// -----------------------------------------------------------------------------
// CBTGPSPositioner::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CBTGPSPositioner* CBTGPSPositioner::NewL(TAny* aConstructionParameters)
    {
    CBTGPSPositioner* self = new( ELeave ) CBTGPSPositioner;

    CleanupStack::PushL( self );
    self->ConstructL(aConstructionParameters);
    CleanupStack::Pop(self);

    return self;
    }


// -----------------------------------------------------------------------------
// CBTGPSPositioner::~CBTGPSPositioner
// Destructor.
// -----------------------------------------------------------------------------
//
CBTGPSPositioner::~CBTGPSPositioner()
    {
    TRACESTRING("CBTGPSPositioner::~CBTGPSPositioner")
    if ( iBTGPSExtension )
        {
        if ( iBTGPSExtension->iRequestHandler )
            {
            iBTGPSExtension->iRequestHandler->UnregisterPSY(this);
            }
		delete iBTGPSExtension;
        }
    }

// -----------------------------------------------------------------------------
// NotifyPositionUpdate implements Cpositioner::NotifyPositionUpdate
// Requests position info asynchronously.
// Returns: aPosInfo: A reference to a position info object. This object
//                    must be in scope until the request has completed.
//                    The position (TPosition) of this position info object
//                    must be in WGS84 geodetic datum.
//          aStatus: The request status
//
// -----------------------------------------------------------------------------
//
void CBTGPSPositioner::NotifyPositionUpdate(TPositionInfoBase& aPosInfo,
                                            TRequestStatus& aStatus)
    {
    TRACESTRING("CBTGPSPositioner::NotifyPositionUpdate")

    //Clear position info
    ClearPositionInfo(aPosInfo);
    
    const CBTGPSFix* fix = NULL;
    TTime maxAge;

    aStatus = KRequestPending;

    iBTGPSExtension->iPosInfo = &aPosInfo;
    iBTGPSExtension->iStatus = &aStatus;
    GetMaxAge(maxAge);

    //Check if last location can be used
    TInt result = iBTGPSExtension->iRequestHandler->LastLocation(fix,maxAge,
        IsPartialUpdateAllowed());

    if( result  == KErrNone )
        {
        TInt err(KErrNone);
        
        switch(fix->FixState())
            {
            case CBTGPSFix::EFixValidityUnkown:
                {
                //Should never happen
                TRACESTRING("CBTGPSPositioner::NotifyPositionUpdate: \
INTERNAL ERROR: CBTGPSFix::ENull.")
                err = KPositionQualityLoss;
                break;
                }
            case CBTGPSFix::EFixNotValid:
                {
                TRACESTRING("CBTGPSPositioner::NotifyPositionUpdate: \
Last known location: CBTGPSFix::ENotValid.")
                err = fix->FillPositionInfo(*(iBTGPSExtension->iPosInfo));
                if(err == KErrNone)
                    {
                    err = KPositionPartialUpdate;
                    }
                break;
                }
            case CBTGPSFix::EFixValid2D:
            case CBTGPSFix::EFixValid3D:
                {
                err = fix->FillPositionInfo(*(iBTGPSExtension->iPosInfo));
                break;
                }
            default:
                {
                //Should never happen
                TRACESTRING("CBTGPSPositioner::NotifyPositionUpdate: \
INTERNAL ERROR: fix unknown.")
                err = KErrGeneral;
                break;
                }
            }
            TRACESTRING2("CBTGPSPositioner::Complete request error = %d", err)
            User::RequestComplete(iBTGPSExtension->iStatus, err);
        }
    else
        {
        iBTGPSExtension->iActive = ETrue;
        iBTGPSExtension->iRequestHandler->AcquireLocation(this);
        }

    }


// -----------------------------------------------------------------------------
// CancelNotifyPositionUpdate implements Cpositioner::CancelNotifyPositionUpdate
// Cancels position info request.
// -----------------------------------------------------------------------------
//
void CBTGPSPositioner::CancelNotifyPositionUpdate()
    {
    TRACESTRING("CBTGPSPositioner::CancelNotifyPositionUpdate")

    if ( iBTGPSExtension->iActive )
        {
        iBTGPSExtension->iActive = EFalse;
        iBTGPSExtension->iPosInfo = NULL;
        iBTGPSExtension->iRequestHandler->CancelAcquireLocation(this);

        TRACESTRING2("CBTGPSPositioner::Complete request error = %d", KErrCancel)
        User::RequestComplete(iBTGPSExtension->iStatus,KErrCancel);
        }
    }


// -----------------------------------------------------------------------------
// TrackingOverridden implements Cpositioner::TrackingOverridden
// Indicate if the PSY has overridden tracking.
// -----------------------------------------------------------------------------
//
TBool CBTGPSPositioner::TrackingOverridden() const
    {
    return ETrue;
    }


// -----------------------------------------------------------------------------
// TrackingOverridden implements Cpositioner::TrackingOverridden
// Initiate a tracking session.
// -----------------------------------------------------------------------------
//
void CBTGPSPositioner::StartTrackingL(
                                const TTimeIntervalMicroSeconds& aInterval)
    {
    TRACESTRING("CBTGPSPositioner::StartTrackingL")
    iBTGPSExtension->iRequestHandler->TrackingSessionStartL(this,aInterval);
    }

// -----------------------------------------------------------------------------
// StopTracking implements Cpositioner::StopTracking
// Any outstanding requests will be cancelled.
// -----------------------------------------------------------------------------
//
void CBTGPSPositioner::StopTracking()
    {
    TRACESTRING("CBTGPSPositioner::StopTracking")
    iBTGPSExtension->iRequestHandler->TrackingSessionStop(this);
    }

// -----------------------------------------------------------------------------
// CBTGPSPositioner::RequestCompleteNotify implements
// MBTGPSRequestCompleteListener::RequestCompleteNotify
// -----------------------------------------------------------------------------
//
TBool CBTGPSPositioner::RequestCompleteNotify(
        const CBTGPSFix* aFix,
        TInt aErr)
    {
    TRACESTRING("CBTGPSPositioner::RequestCompleteNotify start...")
    TRACESTRING2("error = %d", aErr)
    TBool completed = EFalse;
    
    //Validate the NMEA Buffer index and bottom
    if(aFix!=NULL)
        {
        aFix->ValidateNmeaBufferIndex(
            iNmeaIndex,
            iNmeaBottom);
        }
    
    //If there was error, pass it
    if ( (aErr < 0) || (KPositionQualityLoss == aErr) || (aFix==NULL))
        {
        ClearPositionInfo(*iBTGPSExtension->iPosInfo);
        iBTGPSExtension->iActive = EFalse;

        TRACESTRING2("CBTGPSPositioner::Complete request error = %d", aErr)
        User::RequestComplete(iBTGPSExtension->iStatus,aErr);
        completed = ETrue;
        }
    //No error, complete with fix
    else
        {
        TRACESTRING2("fix type = %d", aFix->FixState());

        TInt err = KErrNone;
        
        switch(aFix->FixState())
            {
            case CBTGPSFix::EFixValidityUnkown:
            case CBTGPSFix::EFixNotValid:
                {
                if ( IsPartialUpdateAllowed() )
                    {
                    //Complete the fix when client accept partial update. 
                    //Otherwise, continue
                    completed = ETrue;
                    err = KPositionPartialUpdate;
                    }
                }
                break;
            case CBTGPSFix::EFixValid2D:
            case CBTGPSFix::EFixValid3D:
                completed = ETrue;
                err = KErrNone;
                break;
            default:
                {
                TRACESTRING("CBTGPSPositioner::RequestCompleteNotify: \
INTERNAL ERROR: fix unknown.")
                completed = ETrue;
                err = KErrGeneral;
                break;
                }
            }
        
        if(completed)
            {
            TInt nmeaIndex = iNmeaIndex;
            TInt fillErr = aFix->FillPositionInfo(
                *iBTGPSExtension->iPosInfo,
                &nmeaIndex);
            
            if(fillErr != KErrNone)
                {
                err = fillErr;
                }
            else
                {
                iNmeaIndex = nmeaIndex;
                }
                
            iBTGPSExtension->iActive = EFalse;

            TRACESTRING2("CBTGPSPositioner::Complete request error = %d", err)
            User::RequestComplete(iBTGPSExtension->iStatus,err);
            }
        
        }
    return completed;
    }

// -----------------------------------------------------------------------------
// CBTGPSPositioner::ReportStatus
// Reports the PSY status to the MLFW
// -----------------------------------------------------------------------------
void CBTGPSPositioner::ReportStatus(const TPositionModuleStatus& aStatus)
    {
    MPositionerStatus* statusInf = this->PositionerStatus();
    statusInf->ReportStatus(aStatus);
    }

// -----------------------------------------------------------------------------
// CBTGPSPositioner::SetInitialNmeaBufferBottom
// -----------------------------------------------------------------------------
void CBTGPSPositioner::SetInitialNmeaBufferBottom(TInt aIndex)
    {
    iNmeaIndex = aIndex;
    }

// -----------------------------------------------------------------------------
// CBTGPSPositioner::ClearPositionInfo
// Clears the position info
// -----------------------------------------------------------------------------
void CBTGPSPositioner::ClearPositionInfo(TPositionInfoBase& aPosInfo)
    {
    if (aPosInfo.PositionClassType() & EPositionSatelliteInfoClass)
        {
        // TPositionSatelliteInfo
        (void) new (&aPosInfo) (TPositionSatelliteInfo);
        }
    else if (aPosInfo.PositionClassType() & EPositionCourseInfoClass)
        {
        // TPositionCourseInfo
        (void) new (&aPosInfo) (TPositionCourseInfo);
        }
    else if (aPosInfo.PositionClassType() & EPositionGenericInfoClass)
        {
        // HPositionGenericInfo
        HPositionGenericInfo* genInfo =
            static_cast<HPositionGenericInfo*> ( &aPosInfo );
        
        genInfo->ClearPositionData();
        }
    else if (aPosInfo.PositionClassType() & EPositionInfoClass)
        {
        // TPositionInfo
        (void) new (&aPosInfo) (TPositionInfo);
        }
    else
        {
        // Unknown type, this should never happen
        // --> Panic if we get here
        Panic(EPanicUnknownPositioningClass);
        }

    aPosInfo.SetModuleId(ImplementationUid());
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CBTGPSPositioner::CBTGPSPositioner()
    {
    iNmeaIndex = KBTGPSNmeaIndexNotSet;
    iNmeaBottom = KBTGPSNmeaIndexNotSet;
    }

// -----------------------------------------------------------------------------
// CBTGPSPositioner::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CBTGPSPositioner::ConstructL(TAny* aConstructionParameters)
    {
    // Must call BaseConstructL first thing during
    // construction.
    CLEARTRACELOG;
    
    TRACESTRING("CBTGPSPositioner::ConstructL")
    BaseConstructL(aConstructionParameters);

    iBTGPSExtension = new (ELeave) TBTGPSExtension;

    iBTGPSExtension->iRequestHandler = CBTGPSRequestHandler::GetInstanceL();
    iBTGPSExtension->iRequestHandler->RegisterPSYL(this);
    }


// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(
    TInt& aTableCount)
    {
    aTableCount =1;
    return &KFactoryPtr;
    }

//  End of File