/*

* Copyright (c) 2005 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 SUPL PSY location requestor

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <centralrepository.h>

#include <npppsyinternalcrkeys.h>

#include "suplpsyrequestor.h"

#include "suplpsygenericinfouser.h"

#include "suplpsylogging.h"

#include "suplpsypanic.h"

#include "suplpsy.hrh"

#include <epos_suplterminalconstants.h>

// ===================== ==   ==   ==   == AL FUNCTIONS ===============================

//Constants

const TInt KGenericInfoIncreaseStep = 1024; //1k

// ==================== ==   ==   ==   == BER FUNCTIONS ===============================

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

// CSuplPsyRequestor::CSuplPsyRequestor

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

// might leave.

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

//

CSuplPsyRequestor::CSuplPsyRequestor( const TCallBack& aObserver ) 

        : CActive( EPriorityStandard ),

          iObserver( aObserver ),

          iFirstReq(ETrue),

          iTtnfFlag(EFalse),

          iPrevFixSuccess(EFalse)

    {

    CActiveScheduler::Add( this );

    }

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

// CSuplPsyRequestor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSuplPsyRequestor::ConstructL()

    {

    TRACESTRING( "CSuplPsyRequestor::ConstructL start" )

    //Connect to SUPL server

    User::LeaveIfError( iSuplServer.Connect() );

    //Construct iPositionInfo;

    iPositionInfo = ConstructGenericInfoL();

    CRepository *iRepository = CRepository::NewL(KCRUidNppPsy);

    //TInt keyValue;

    TInt ret = iRepository->Get(KPSYTimeToNextFix, iTtnf);

    delete iRepository;

    iRepository = NULL;

    TRACESTRING( "CSuplPsyRequestor::ConstructL end" )

    }

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

// CSuplPsyRequestor::ConstructGenericInfoL

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

//

HPositionGenericInfo* CSuplPsyRequestor::ConstructGenericInfoL( 

    TInt aBufferSize ) const

    {

    HPositionGenericInfo* positionInfo = HPositionGenericInfo::NewL( aBufferSize );

    //Set all requested fields

    TInt count = SuplPsyGenericInfoUser::SupportedFieldsCount();

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

        {

        positionInfo->SetRequestedField( 

            SuplPsyGenericInfoUser::SupportedFieldAt( i ) );

        }

    return positionInfo;

    }

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

// CSuplPsyRequestor::NewL

// Two - phased constructor.

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

//

CSuplPsyRequestor* CSuplPsyRequestor::NewL( 

        const TCallBack& aObserver )

    {

    CSuplPsyRequestor* self = new( ELeave ) CSuplPsyRequestor( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSuplPsyRequestor::~CSuplPsyRequestor

// Destructor

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

//

CSuplPsyRequestor::~CSuplPsyRequestor()

    {

    Cancel();

    iSuplSession.Close();

    iSuplServer.Close();

    delete iPositionInfo;

    }

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

// CSuplPsyRequestor::RunL

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

//

void CSuplPsyRequestor::RunL()

    {

    TRACESTRING2( "CSuplPsyRequestor::RunL status=%d", iStatus.Int() )

    //Call callback function

    if ( iStatus.Int() >= KErrNone )

        {

	        if (!iTtnfFlag)                

	            {                

										//Get position info

										HPositionGenericInfo* posInfo = ConstructGenericInfoL();

										// Set module id

										TPositionInfo* position = static_cast<TPositionInfo*> (posInfo );

										TUid implUid = { KSuplPsyImplUid };

										position->SetModuleId( implUid );

										TRACESTRING( "Calling SUPL FW GetPosition ... " )

										iStatus = iSuplSession.GetPosition( *posInfo );

										while ( iStatus.Int() == KErrPositionBufferOverflow )

										{

										//Not enough buffer allocated.Increase the buffer

										TInt bufferSize = posInfo->BufferSize();

										delete posInfo;

										posInfo = ConstructGenericInfoL( bufferSize + KGenericInfoIncreaseStep );

										iStatus = iSuplSession.GetPosition( *posInfo );

										}

									            if ( iStatus.Int() >= KErrNone )

									                {

									                delete iPositionInfo;

									                iPositionInfo = posInfo;

									                //Set module Id

									                iPositionInfo->SetModuleId( TUid::Uid( KSuplPsyImplUid ) );

									                //Set time

									                TPosition pos;

									                iPositionInfo->GetPosition( pos );

									                TTime now;

									                now.UniversalTime();

									                pos.SetTime( now );

									                iPositionInfo->SetPosition( pos );

									                iPrevFixSuccess = ETrue;

									                }

									            else

									                {

									                delete posInfo;

									                iPrevFixSuccess = EFalse;

									                }

	            }

						else

						{

								iTtnfFlag = EFalse; 

								TRACESTRING( "Using previous position... " )

						}                    

        }

    iObserver.CallBack();

    TRACESTRING( "CSuplPsyRequestor::RunL end" )

    }

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

// CSuplPsyRequestor::DoCancel

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

//

void CSuplPsyRequestor::DoCancel()

    {

    if(iSuplSession.SubSessionHandle())

        {

        iSuplSession.CancelRunSession();

        }

    }

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

// CSuplPsyRequestor::RunError

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

//

TInt CSuplPsyRequestor::RunError( TInt aError )

    {

    iStatus = aError;

    iObserver.CallBack();

    return KErrNone;

    }

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

// CSuplPsyRequestor::RequestLocation

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

//

void CSuplPsyRequestor::RequestLocation()

    {

    TRACESTRING( "CSuplPsyRequestor::RequestLocation start" )

    //Check if location request has been made already

    if ( IsActive() )

        {

        return;

        }

    // Check if the request is made withing TTNF,

    // if so return the previous computed position 

    // if it was success

    if (!iFirstReq && iPrevFixSuccess)

         if (IsRequestInTtnf())

            {

            iTtnfFlag = ETrue;                

            iStatus = KRequestPending;

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            TRACESTRING( "Interval is within TTNF, returning. Returning Previous Position." )

            return;

            }            

    //Open SUPL session if needed

    if ( iSuplSession.SubSessionHandle() == NULL )

        {

        TInt err = iSuplSession.Open( iSuplServer );

        //If can't open session call RunL in next active scheduler round

        if ( err != KErrNone )

            {

            iStatus = KRequestPending;

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, err );

            TRACESTRING2( "Could not open subsession:%d", err )

            return;

            }

        }

		TRACESTRING( "Calling SUPL FW RunSession... " )

    //Make location request

    iSuplSession.RunSession( iStatus, 

        KGpsSETAssisted | KAFLT | KECID | KEOTD | KOTDOA | KCID, 0, iFirstReq );

    if (iFirstReq)

        {            

        iFirstReq = EFalse;                

        }

    SetActive();

    TRACESTRING( "CSuplPsyRequestor::RequestLocation end" )

    }

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

// CSuplPsyRequestor::GetRequestResult

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

//

TInt CSuplPsyRequestor::GetRequestResult()

    {

    return iStatus.Int();

    }

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

// CSuplPsyRequestor::GetLocation

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

//

const HPositionGenericInfo& CSuplPsyRequestor::GetLocation()

    {

    return *iPositionInfo;

    }

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

// CSuplPsyRequestor::ResetLastPosition

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

//

void CSuplPsyRequestor::ResetLastPosition()

    {

//    iPositionInfo->ClearPositionData();

    }

TBool CSuplPsyRequestor::IsRequestInTtnf()

    {

    iTtnfFlag = EFalse;  	

    TTime now;

    now.UniversalTime();

    TInt diff = 1000000;

    TPosition pos;

    iPositionInfo->GetPosition( pos );

    TTimeIntervalSeconds secs;

    now.SecondsFrom(pos.Time(), secs); 

    diff = diff * secs.Int();

		TRACESTRING2( "Time diff. for request...:%d", diff )

    if (diff <= iTtnf)

        return ETrue;            

    return EFalse;

    }        

//  End of File