/*
* Copyright (c) 2006 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:  This is NPP PSY Positioning Plug-in ( PSY ).
*
*/



// INCLUDE FILES
#include <e32std.h>            
#include <lbspositioninfo.h>      // TPositionInfoBase
#include <lbs/epos_cpositioner.h> // CPositioner

#include "npppsypositioner.h"
#include "npppsysingletonhandler.h"
#include "npppsysettinghandler.h"
#include "npppsystatushandler.h"
#include "npppsyrequester.h"
#include "npppsylogging.h"
#include "npppsypanic.h"
#include "npppsy.hrh"



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

// -----------------------------------------------------------------------------
// CNppPsyRequester::CNppPsyRequester
// C++default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CNppPsyRequester::CNppPsyRequester( CNppPsyPositioner& aPositioner )
    : CActive( CActive::EPriorityStandard ),
      iNppPsyPositioner( aPositioner )
    {
    CActiveScheduler::Add( this );
    }


// -----------------------------------------------------------------------------
// CNppPsyRequester::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::ConstructL()
    {
    TRACESTRING( "CNppPsyRequester::ConstructL start" )
    
    //Singleton handler
    iSingletonHandler = CNppPsySingletonHandler::GetInstanceL( 
        iNppPsyPositioner.StatusReportInterface() );
    
    TRACESTRING( "CNppPsyRequester::ConstructL end" )
    }


// -----------------------------------------------------------------------------
// CNppPsyRequester::NewL
// Two - phased constructor.
// -----------------------------------------------------------------------------
//
CNppPsyRequester* CNppPsyRequester::NewL( CNppPsyPositioner& aPositioner )
    {
    CNppPsyRequester* self = new( ELeave ) CNppPsyRequester( aPositioner );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

    
// -----------------------------------------------------------------------------
// CNppPsyRequester::~CNppPsyRequester
// 
// -----------------------------------------------------------------------------
//
CNppPsyRequester::~CNppPsyRequester()
    {
    Cancel();
    
    iPsyList.Close();
    delete iPositioner;
    
    if ( iSingletonHandler )
        {
        iSingletonHandler->ReleaseInstance();
        }
        
    TRACESTRING( "CNppPsyRequester:: destructed" )
    }


// -----------------------------------------------------------------------------
// CNppPsyRequester::NotifyPositionUpdate
// 
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::NotifyPositionUpdate ( 
    TPositionInfoBase& aPosInfo,  
    TRequestStatus&    aStatus )
    {
    TRACESTRING( "CNppPsyRequester::NotifyPositionUpdate start" )

    //NPP PSY will not handle simultaneous location request
    if ( iRequestStatus )
        {
        Panic( EPanicPositionRequestOngoing );
        }
    
    //Report the request is made
    iSingletonHandler->StatusHandler().IncRequestCount();

    aStatus = KRequestPending;
    iRequestStatus = &aStatus;
    iPositionInfo = &aPosInfo;
    
    //Get PSY list
    TRAPD( err, iSingletonHandler->SettingHandler().GetPsyListL( iPsyList ) );
    if ( err == KErrNone )
        {
        if ( iPsyList.Count() == 0 )
            {
            //Empty PSY List
            CompleteRequest( KPositionQualityLoss );
            }
        else
            {
            MakeLocationRequest();
            }
        }
    else
        {
        CompleteRequest( err );
        }
        
    TRACESTRING( "CNppPsyRequester::NotifyPositionUpdate end" )
    }



// -----------------------------------------------------------------------------
// CNppPsyRequester::RunL
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::RunL()
    {
    //Partial update is not possible for network based positioning
    if ( iStatus.Int() == KErrNone )
        {
        CompleteRequest( KErrNone );
        }
    else
        {
        //Try next PSY
        if ( iStatus.Int() < 0 && iStatus != KErrCancel )
            {
            //Move Psy to last.
            iSingletonHandler->SettingHandler().MovePsyLast( iPsyList[0] );
            //iPsyList can't be empty
            }
            
            //Remove this PSY from list
            iPsyList.Remove( 0 );
            
            //Try next PSY
            MakeLocationRequest();
        }
    }

// -----------------------------------------------------------------------------
// CNppPsyRequester::DoCancel
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::DoCancel()
    {
    if ( iRequestStatus )
        {
        CompleteRequest( KErrCancel );
        }
    
    if ( iPositioner )
        {
        iPositioner->CancelNotifyPositionUpdate();
        }
    }

// -----------------------------------------------------------------------------
// CNppPsyRequester::RunError
// -----------------------------------------------------------------------------
//
TInt CNppPsyRequester::RunError( TInt /*aErr*/ )
    {
    //shall not be called.
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CNppPsyRequester::MakeLocationRequest
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::MakeLocationRequest()
    {
    //Get the uid of the first PSY
    if ( iPsyList.Count() == 0 )
        {
        //List is empty
        TInt preError = iStatus.Int();
        preError = preError == KErrNone?KErrNotFound:preError;
        CompleteRequest( preError );
        return;
        }

    TUid impUid = iPsyList[0];
    
    TInt err( KErrNone );
    
    //Load PSY
    if ( !iPositioner || iPositioner->ImplementationUid() != impUid )
        {
        if ( iPositioner )
            {
            iPositioner->CancelNotifyPositionUpdate();
            }
            
        delete iPositioner;
        iPositioner = NULL;
        
        TRAP( err,
            iPositioner =
                CPositioner::NewL( impUid, iNppPsyPositioner ) );
        
        if ( err == KErrNotFound )
            {
            //Psy uid is in the list but psy is not found in system
            iSingletonHandler->SettingHandler().RemovePsy( impUid ); 
            //error ignored.
            }
        }
    

    if ( err == KErrNone )
        {
        iStatus = KRequestPending;
        iPositioner->NotifyPositionUpdate( *iPositionInfo, iStatus );
        SetActive();
        }
    else
        {
        //Report the first psy failure
        iStatus = KRequestPending;
        SetActive();
        TRequestStatus* status = &iStatus;
        User::RequestComplete( status, err );
        }
    }


// -----------------------------------------------------------------------------
// CNppPsyRequester::CompleteRequest
// -----------------------------------------------------------------------------
//
void CNppPsyRequester::CompleteRequest( TInt aErr )
    {
    //Set UID before complete the request
    iPositionInfo->SetModuleId( TUid::Uid( KNppPsyImplUid ) );
    User::RequestComplete( iRequestStatus, aErr );

    //Report the request is completed
    iSingletonHandler->StatusHandler().DecRequestCount();
    }

//  End of File