// Copyright (c) 2008-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:

//

/**

 @file

 @InternalComponent

*/

#include <e32base.h>

#include <lbs/epos_mpositionerstatus.h>

#include <ecom/implementationproxy.h>

#include <lbssatellite.h>

#include "utilfunctions.h"

#include "crequesthandler.h"

#include "cresponsehandler.h"

#include "cadaptationpositioner.h"

#include "psypanic.h"

#include "psylogging.h"

#include "lbsprocessuiddefs.h"

#include "lbsdevloggermacros.h"

const TUint KWarmDownTimeout   = 10000000;//10s

CAdaptationPositioner::CAdaptationPositioner()

    {

    LBSLOG(ELogP1, "CAdaptationPositioner::CAdaptationPositioner()");

    iState = ERequestStateInitial;

    }

/**

* Destructor

*/

CAdaptationPositioner::~CAdaptationPositioner()

    {

    LBSLOG(ELogP1, "CAdaptationPositioner::~CAdaptationPositioner()");

	StopMaxFixTimer();

	delete iMaxFixTimer;

	iMaxFixTimer = NULL;

	StopWarmDownTimer();    

	delete iWarmDownTimer;

	iWarmDownTimer = NULL;

	CancelNotifyPositionUpdate();

    if(iEnvironment)

    	{

    	iEnvironment->CloseInstance();

    	}

	}

/**

* CancelNotifyPositionUpdate implements CAdaptationPositioner::CancelNotifyPositionUpdate

* Cancels position info request.

*/

void CAdaptationPositioner::CancelNotifyPositionUpdate()

    {

    LBSLOG(ELogP1, "CAdaptationPositioner::CancelNotifyPositionUpdate()");

    // Stop timers

	StopMaxFixTimer();

	StopWarmDownTimer();    

    CancelNotifyPositionUpdate(KErrCancel);

    }

/**

* CancelNotifyPositionUpdate implements CAdaptationPositioner::CancelNotifyPositionUpdate(TInt)

* Cancels position info request with reason. This reason allows the S60 Loc Server to distinguish between a real user cancel

* and a timeout - in the case of the latter the LS calls CancelNotifyPositionUpdate(KErrTimedOut), 

* in the former he passes no error.

*/

void CAdaptationPositioner::CancelNotifyPositionUpdate(TInt aError)

    {

    LBSLOG2(ELogP1, "CAdaptationPositioner::CancelNotifyPositionUpdate(aError) %d", aError);

    if( iActive )

        {

        LBSLOG2(ELogP1, "CAdaptationPositioner::Complete request error = %d", aError);

		UpdateFailed(KErrCancel);

        TRAP_IGNORE(iRequestHandler->ReMergeWithCancelRequestL(aError)); // Nothing we can do about a leave here

        if(aError == KErrTimedOut && IsTracking())

        	{

        	// The last tracking request timedout so we need to schedule one for the next interval

    		TTime timeNow;

    		timeNow.UniversalTime();   

    		iActive = ETrue;

        	UpdateTrackingTime(timeNow);

        	TRAPD(error, iRequestHandler->SubmitNewRequestL(this)); // Nothing we can do about a leave here

            if(!error)

                {

                TRAP_IGNORE(StartMaxFixTimerL());// (re)start maxfix timer so that we know when the module has stopped trying

                } 	

        	}

    	}

    }

/**

* Indicate if the PSY has overridden tracking. The default

* implementation returns EFalse.

* @return ETrue if PSY has own timer, otherwise EFalse.

*/

TBool CAdaptationPositioner::TrackingOverridden() const

    {

    return ETrue;

    }

/**

* Initiate a tracking session.

*

* @param aInterval Interval for position requests.

*/

void CAdaptationPositioner::StartTrackingL(const TTimeIntervalMicroSeconds& aInterval)

    {

	LBSLOG2(ELogP1, "CAdaptationPositioner::StartTrackingL, interval = %d", aInterval);

	TTime timeNow;

    TTime trackingTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(iTargetTime, aInterval);

	timeNow.UniversalTime();

	iTrackingInterval = aInterval;

    if(! (trackingTime < timeNow)) // if this is not a default proxy call to StartTracking

	    {

    	LBSLOG(ELogP1, "Non-DefProxy Start");

	    SetupTrackingRequestL();

		iRequestHandler->SubmitNewRequestL(this);

	    }

    }

/**

* Stop a periodic update session.

*/

void CAdaptationPositioner::StopTracking()

    {

    LBSLOG(ELogP1, "CAdaptationPositioner::StopTracking");

    iTrackingInterval = 0;

    }

/**

* Restart tracking after a missed update

*/

void CAdaptationPositioner::UpdateTrackingTime(TTime& aTimeNow)

	{

	LBSLOG(ELogP1, "CAdaptationPositioner::UpdateTrackingTime restarting tracking");

	TUint multiplier = ( (aTimeNow.Int64() - iTargetTime.Int64()) / iTrackingInterval.Int64() );

	TTimeIntervalMicroSeconds timeToAdd = ( (multiplier + 1) * iTrackingInterval.Int64() );

	if (timeToAdd < 0)

		{

		iTargetTime = Time::MaxTTime();

		}

	else

		{

		iTargetTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(iTargetTime, timeToAdd);

		}

	}

/**

* Submit a request with the target time in the future.

* The positionerQ will deal with issuing a merged request from 

* all active positioners.

*/

void CAdaptationPositioner::SetupTrackingRequestL()

	{

    if(IsTracking())

    	{

    	LBSLOG(ELogP1, "CAdaptationPositioner::SetupTrackingRequestL");

	    iPosInfo = NULL; // This will be filled in by the NPUD when it arrives

	    iActive = ETrue;

	    iTargetTime.UniversalTime();

		#ifdef _DEBUG

	    TDateTime timeNow = iTargetTime.DateTime();

		LBSLOG3(ELogP1, "Time Now = %d.%d", timeNow.Second(), timeNow.MicroSecond());

		#endif

		iTargetTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(iTargetTime, iTrackingInterval);

		#ifdef _DEBUG

		timeNow = iTargetTime.DateTime();

		LBSLOG3(ELogP1, "Target Time = %d.%d", timeNow.Second(), timeNow.MicroSecond());

		#endif

		StartMaxFixTimerL();

    	}

	}

/**

* Check if we're tracking.

*

* @return ETrue if we are tracking

*/

TBool CAdaptationPositioner::IsTracking()

	{

	return (iTrackingInterval != 0);

	}

/**

* Attempt to use an old position

*

* @param aPosInfo The clients position info

* @return ETrue if the old position was used

*/

TBool CAdaptationPositioner::UseLastLocation(TPositionInfoBase& aPosInfo)

	{

    TTime maxAge;

	TBool result = EFalse;

    GetMaxAge(maxAge);

    if(maxAge > 0)

    	{

    	CResponseHandler* responseHandler = iEnvironment->GetResponseHandler(); 

    	result = responseHandler->GetLastPosition(aPosInfo, maxAge, IsPartialUpdateAllowed());

	    if( result ) // Use last location

	        {

	        TInt err = KErrNone;

	  	 	TPosition pos;

	  	 	static_cast<TPositionInfo&>(aPosInfo).GetPosition(pos);

	        if(Partial(pos))

	        	{

	        	err = KPositionPartialUpdate;

	        	}

	        LBSLOG(ELogP1, "CAdaptationPositioner::NotifyPositionUpdate returning old position");

	        // nb: this will deal with tracking requests properly:

	        if(CompleteRequest(static_cast<TPositionInfo&>(aPosInfo), err))

	        	{

	            TRAP_IGNORE(SetupTrackingRequestL());

	        	}

	        }

        }

	return result;

	}

/**

* Attempt to complete an outstanding request if there is one

*

* @param aPositionInfo The retrieved fix.

* @param aError The error code if the request is failed.

* @param aActualTime time of the location update

*/

void CAdaptationPositioner::RequestCompleteNotify(const TPositionInfo& aPositionInfo, TInt aError, TTime& aActualTime)

    {

    LBSLOG(ELogP1, "CAdaptationPositioner::RequestCompleteNotify start...");

    TBool startWarmDown = EFalse;

    TBool completed = EFalse;

    if(iActive)

	    {

	    TPositionModuleInfo::TTechnologyType mode = aPositionInfo.PositionMode();

	    if( (aActualTime >= iTargetTime) || (aError == KPositionCalculationFutile) )

	       	{

        	// Check if the update is partial and if partial updates are allowed

    	 	TPosition pos;

			aPositionInfo.GetPosition(pos);

        	TBool partial = Partial(pos);

			TBool isFNP = (aPositionInfo.PositionMode() == (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted));

			if(isFNP)

				{

        		LBSLOG(ELogP1, "Complete with FNP");

        		/* removing this for now until we decide how to deal with the qualityloss issue on s60 

        		 * since on s60 qualityloss means no position was generated

        		 	if(partial)

        			{

        			CompleteRequest(aPositionInfo, KPositionQualityLoss);

        			}

        		else

        		*/

        			{

        			completed = CompleteRequest(aPositionInfo, KErrNone);

        			// Stop the AGPS Manager if there are no other outstanding requests

        	        TRAP_IGNORE(iRequestHandler->CancelRequestL());

        			}

				}

			else if(partial && IsPartialUpdateAllowed())

	        	{

        		LBSLOG(ELogP1, "Complete with partial");

        		completed = CompleteRequest(aPositionInfo, KPositionPartialUpdate);

        		startWarmDown = ETrue;

	        	}

	        else if(!partial)

		        {

    			LBSLOG(ELogP1, "Complete with non-partial");

    			completed = CompleteRequest(aPositionInfo, KErrNone);

        		// did the module produce an accurate update or is it still trying?

        		if(!IsAccurate(aPositionInfo))

        			{

        			startWarmDown = ETrue;         			

        			}

        		else	// it might be an accurate reference position

        			{

        			TBool isRefPos = (aPositionInfo.ModuleId() == KLbsGpsLocManagerUid) && 

        								(aPositionInfo.PositionMode() == TPositionModuleInfo::ETechnologyNetwork);

        			if(isRefPos)

        				{

        				startWarmDown = ETrue;

        				}

        			}

	        	}

	        else if(aError == KPositionCalculationFutile)

	        	{

	        	// if autonomous return immediately otherwise wait for FNP

	        	if(mode & TPositionModuleInfo::ETechnologyTerminal)

		        	{

	        		LBSLOG(ELogP1, "Complete with futile");

	        		completed = CompleteRequest(aPositionInfo, KPositionQualityLoss);

		        	}

	        	}

	        else

	        	{

		        // position is not futile and is partial but partials are not

		        // allowed. In this case do nothing and wait for further updates

	        	}

        	}

		else

			{

        	LBSLOG(ELogP1, "CAdaptationPositioner::RequestCompleteNotify Ignoring early response");

			}

    	}

    if (completed)

    	{

        TRAP_IGNORE(SetupTrackingRequestL());

    	}

    if(startWarmDown)	// we need to start a warmdown timer

    	{

    	TRAP_IGNORE(StartWarmDownTimerL()); // not much we can do here if warmdown timer not started

    	}

    LBSLOG(ELogP1, "CAdaptationPositioner::RequestCompleteNotify end");

    }

/**

* Attempt to complete an outstanding request if there is one with an error

*

* @param aError The error code if the request is failed.

*/

void CAdaptationPositioner::UpdateFailed(TInt aError)

	{

	LBSLOG(ELogP1,  "CAdaptationPositioner::UpdateFailed()");

	if(iActive)

	    {

		LBSLOG2(ELogP1, "CAdaptationPositioner::Complete request error = %d", aError);

		iActive = EFalse;

		ClearPositionInfo(*iPosInfo);

		if(iClientStatus)

			{

			User::RequestComplete(iClientStatus, aError);

			iClientStatus = NULL;

			}

		LBSLOG2(ELogP1, "iState -> ERequestStatePostInitial from %d", iState);

	    iState = ERequestStatePostInitial;

	    }

	}

/**

* Complete the outstanding request and reset internal state

*

* @param aPositionInfo The retrieved fix.

* @param aError The error code if the request is failed.

*/

TBool CAdaptationPositioner::CompleteRequest(const TPositionInfo& aPositionInfo, TInt aError)

	{

	LBSLOG2(ELogP1, "CAdaptationPositioner::CompleteRequest() with error %d", aError);

	TBool completed = EFalse;

	iActive = EFalse; // Stop another request being sent for this instance of the PSY

	if(iPosInfo)

		{

		TInt error = CopyPositionTypes(*iPosInfo, aPositionInfo);

		__ASSERT_DEBUG(error == KErrNone,

						User::Panic(KAdaptationPanicCategory, EPanicPositionCopyFailed));

		error = error; // this is to stop arm build warnings

		SetModuleId(iPosInfo); // Delegate to the derived class

		User::RequestComplete(iClientStatus, aError);

		iClientStatus = NULL;

		LBSLOG2(ELogP1, "iState -> ERequestStatePostInitial from %d", iState);

	    iState = ERequestStatePostInitial;

        completed = ETrue;

		}

	else

		{

    	LBSLOG(ELogP1, "CAdaptationPositioner::RequestCompleteNotify iPosInfo not set");

		}

	return completed;

	}

/**

* CAdaptationPositioner::ReportStatus

* Reports the PSY status to the MLFW

*

* @param aStatus The new position module status

*/

void CAdaptationPositioner::ReportStatus(const TPositionModuleStatus& aStatus)

    {

    MPositionerStatus* statusInf = this->PositionerStatus();

    statusInf->ReportStatus(aStatus);

    }

/**

 * Clears the fields of the aPosInfo 

 * @param aPosInfo The position information to return

 */

void CAdaptationPositioner::ClearPositionInfo(TPositionInfoBase& aPosInfo)

    {

    if(&aPosInfo != NULL)

	    {

		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

			__ASSERT_DEBUG(0, User::Panic(KAdaptationPanicCategory, EPanicUnknownPositioningClass));

	        }

	    aPosInfo.SetModuleId(ImplementationUid());

	    }

    }

TBool CAdaptationPositioner::IsActive()

	{

	return iActive;

	}

TBool CAdaptationPositioner::IsWarmingDown()

	{

	if(iWarmDownTimer)

		{

		return iWarmDownTimer->IsActive();

		}

	return EFalse;

	}

void CAdaptationPositioner::StartMaxFixTimerL()

	{

	LBSLOG(ELogP1, "CAdaptationPositioner::StartMaxFixTimerL()");

	if(iMaxFixTimer)	// stop any that's currently running

		{

		iMaxFixTimer->Cancel();

		}

	else

		{

		iMaxFixTimer = CLbsCallbackTimer::NewL(*this);

		}

	iMaxFixTimer->EventAfter(iTimeOutInterval, EMaxFixTimerEvent);

	}

void CAdaptationPositioner::StopMaxFixTimer()

	{

	LBSLOG(ELogP1, "CAdaptationPositioner::StopMaxFixTimer()");

	if(iMaxFixTimer)

		{

		iMaxFixTimer->Cancel();

		}

	}

void CAdaptationPositioner::StartWarmDownTimerL()

	{

	TTimeIntervalMicroSeconds32 timeout = KWarmDownTimeout;

	LBSLOG(ELogP1, "CAdaptationPositioner::StartWarmDownTimerL()");

	if(iWarmDownTimer)	// stop any that's currently running

		{

		iWarmDownTimer->Cancel();

		}	

	else

		{

		iWarmDownTimer = CLbsCallbackTimer::NewL(*this);

		}

	iWarmDownTimer->EventAfter(timeout, EWarmDownTimerEvent);