// Copyright (c) 2006-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:
// locationrequesthandler.cpp
// 
//


#include "lbscommoninternaldatatypes.h"
#include "lbslocationrequesthandler.h"
#include "lbslocsourcegps.h"
#include "lbsdevloggermacros.h"
#include <lbs/lbslocerrors.h>

CLocationRequestHandler * CLocationRequestHandler::NewL
	(
	MLocationRequestHandlerObserver& aObserver, 
	const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel
	)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::NewL()\n");
	CLocationRequestHandler * self = new(ELeave) CLocationRequestHandler (aObserver, aChannel);
	CleanupStack::PushL(self);
	self->ConstructL(aChannel);
	CleanupStack::Pop();
	return self;
	}
	
CLocationRequestHandler::CLocationRequestHandler(MLocationRequestHandlerObserver& aObserver,	const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel) : 
CActive(CActive::EPriorityStandard),	
iObserver(aObserver),
iChannel(aChannel),
iRequestState(EIdle)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::CLocationRequestHandler()\n");
	}

void CLocationRequestHandler::ConstructL(const RLbsPositionUpdateRequests::TChannelIdentifer& aChannel)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::ConstructL()\n");
	CActiveScheduler::Add(this);
	iposUpdateReq.OpenL(aChannel);
	iTimer = CLbsCallbackTimer::NewL(*this);
	
	iposUpdateReq.NotifyPositionUpdateRequestChange(iStatus);
	SetActive();
	}

CLocationRequestHandler::~CLocationRequestHandler()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::~CLocationRequestHandler()\n");
	Cancel();
	iposUpdateReq.Close();
	delete iTimer;
	}
	
void CLocationRequestHandler::ActivateRequest()
	{
	TLbsLocRequestQualityInt fred;
	
	LBSLOG(ELogP1, "CLocationRequestHandler::ActivateRequest()\n");
	// Invalidate if any
	InvalidateRequest();

	TTime timeNow;
	TTime endTime;
	timeNow.UniversalTime();
	iRequestActivationTime = timeNow;
	
	// TT=0 means immediate request
	endTime = iRequest.TargetTime() != 0 ? iRequest.TargetTime() : timeNow;
    endTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(endTime,iRequest.RequestQuality().MaxFixTime());
	
	if (endTime > timeNow)	// if it end in the future
		{
		iTimer->EventAtUTC(endTime, 0);
		iRequestState = EActive;
		}
	}
	
void CLocationRequestHandler::InvalidateRequest()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::InvalidateRequest()\n");
	iRequestState = EIdle;
	iTimer->Cancel();
	}
	
TBool CLocationRequestHandler::IsRequestActive() const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::IsRequestActive()\n");
	return	iRequestState == EActive || iRequestState == EActiveRestartOnTargetTime;
	}
	
TTime CLocationRequestHandler::GetStartTime() const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::GetStartTime()\n");
	return (iRequest.TargetTime());
	};

TTime CLocationRequestHandler::GetTimeActivated() const
	{
	// Returns the time the request was actually activated
	// Needed when calculating max fix time for combined requests
	// when TargetTime is zero (i.e. immediate requests)
	LBSLOG(ELogP1, "CLocationRequestHandler::GetTimeActivated()\n");
	return iRequestActivationTime;
	};

TLbsLocRequestQualityInt CLocationRequestHandler::GetQuality() const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::GetQuality()\n");

	return iRequest.RequestQuality();
	};

TBool CLocationRequestHandler::GetNewClient() const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::GetNewClient()\n");
	return iRequest.NewClient();
	};

void CLocationRequestHandler::DoCancel()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::DoCancel()\n");
	iposUpdateReq.CancelNotifyPositionUpdateRequestChange();
	iTimer->Cancel();
	}

//------------------------------------------------------------------------------------------------------------
void CLocationRequestHandler::RunL()
	{
	LBSLOG2(ELogP1, "CLocationRequestHandler::RunL() Begin. Status: %d\n", iStatus.Int());
	__ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Panic(KLbsAGPSManFault, iStatus.Int()));
	
	iposUpdateReq.NotifyPositionUpdateRequestChange(iStatus);
	SetActive();
	
	ProcessAnyOutstandingRequestL();
	LBSLOG(ELogP1, "CLocationRequestHandler::RunL() End\n");
	}

/* When ran the first time (after AGPS Manager startup) the last known
   system status is passed to the NG */
void CLocationRequestHandler::ProcessAnyOutstandingRequestL()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::ProcessAnyOutstandingRequestL() Begin\n");

	TLbsPositionUpdateRequestBase updateRequest; 
	User::LeaveIfError(iposUpdateReq.GetPositionUpdateRequest(updateRequest));
	
	TLbsPositionUpdateRequest* request = (reinterpret_cast<TLbsPositionUpdateRequest*>(&updateRequest));

	// Process the requst
	switch(updateRequest.Type())
		{
		case TLbsPositionUpdateRequestBase::ECancel:
			LBSLOG(ELogP2, "Location Cancel received from LS or NRH.\n");
			ProcessSystemStatusAdvice(updateRequest);
			
			if(!iLastRequestWasCancel)
				{
				InvalidateRequest();
				iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonCancel);
				iLastRequestWasCancel = ETrue;
				}
			break;
		
		case TLbsPositionUpdateRequestBase::EUpdateRequest:
			LBSLOG(ELogP2, "Location Request received from LS or NRH.\n");
			LBSLOG5(ELogP2, "   TargetTime:   %d:%d:%d.%d", request->TargetTime().DateTime().Hour(), 
															request->TargetTime().DateTime().Minute(),
															request->TargetTime().DateTime().Second(),
															request->TargetTime().DateTime().MicroSecond());
			LBSLOG2(ELogP2, "   Max Fix Time: %ld", request->RequestQuality().MaxFixTime().Int64());
			LBSLOG3(ELogP2, "   Accuracy H/V: %f/%f", request->RequestQuality().MinHorizontalAccuracy(),
													  request->RequestQuality().MinVerticalAccuracy());

			iLastRequestWasCancel = EFalse;
			ProcessSystemStatusAdvice(updateRequest);				
					
			iRequest = *request;
			ActivateRequest();
			if (iRequestState == EActive)
				{
				iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonRequest); // call back to MainLogic
				}
			break;

		case TLbsPositionUpdateRequestBase::EStatus:
			LBSLOG(ELogP2, "Status received from LS or NRH.\n");
			iLastRequestWasCancel = EFalse;
			ProcessSystemStatusAdvice(updateRequest);
			break;
			
		default:
			{
			LBSLOG_WARN2(ELogP2, "Unknown update request type: %d \n", updateRequest.Type());
			iLastRequestWasCancel = EFalse;
			break;
			}
		}
	LBSLOG(ELogP1, "CLocationRequestHandler::ProcessAnyOutstandingRequestL() End\n");
	}

/** */
void CLocationRequestHandler::ProcessSystemStatusAdvice(TLbsPositionUpdateRequestBase& aRequest)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::ProcessSystemStatusAdvice()\n");
	TLbsPositionUpdateRequestStatus* status;
	status = reinterpret_cast<TLbsPositionUpdateRequestStatus*>(&aRequest);
	ProcessPowerModeAdvice(status->PowerAdvice());
	iObserver.OnSystemStatusAdvice(iChannel, status->Tracking());
	}

void CLocationRequestHandler::ProcessPowerModeAdvice(TLbsPositionUpdateRequestBase::TPowerAdvice aMode)
 	{
 	LBSLOG(ELogP1, "CLocationRequestHandler::ProcessPowerModeAdvice()\n");
 	if (TLbsPositionUpdateRequestBase::ENoPowerAdvice != aMode)
 		{
 		CLbsLocationSourceGpsBase::TPowerMode powerMode;
 		switch (aMode)
 			{
 			//Identify the power advice being sent
 			case TLbsPositionUpdateRequestBase::EPowerAdviceOn:
 				{
 				powerMode = CLbsLocationSourceGpsBase::EPowerModeOn;
 				break;
 				}
 			case TLbsPositionUpdateRequestBase::EPowerAdviceStandby:
 				{
 				powerMode = CLbsLocationSourceGpsBase::EPowerModeStandby;
 				break;
 				}
			case TLbsPositionUpdateRequestBase::EPowerAdviceOff:
 				{
 				powerMode = CLbsLocationSourceGpsBase::EPowerModeOff;
 				break;
 				}
 			case TLbsPositionUpdateRequestBase::EPowerAdviceClosed:
 				{
 				powerMode = CLbsLocationSourceGpsBase::EPowerModeClose;
 				break;
 				}
 			default:
 				{
 				LBSLOG_WARN2(ELogP2, "Unknown power mode: %d \n", aMode);
 				break;
 				}
 			}
 		
 		iObserver.OnPowerModeAdvice(iChannel, powerMode);
 		}
 	}
 	
TBool CLocationRequestHandler::IsAccuracyRequirementMet(TReal32 aHorizontalAccuracy, TReal32 /*aVerticalAccuracy*/)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::ProcessLocationUpdate()\n");
	TBool rc = EFalse;
	if (EIdle != iRequestState)
		{
		TLbsLocRequestQualityInt quality = GetQuality();

		TTimeIntervalMicroSeconds mft = quality.MaxFixTime();

		TTime targ = iRequest.TargetTime();
		if (targ == TTime(0))
			{
			targ.UniversalTime();
			}
		TTime endtarg = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(targ,mft);
		
		TTime now;
		now.UniversalTime();
		
		if ((now >= targ) && (now <= endtarg) &&
			(aHorizontalAccuracy <= quality.MinHorizontalAccuracy()))
			{
			LBSLOG(ELogP2, "Time window ok. Quality meet. Invalidating request.\n");
			InvalidateRequest();
			rc = ETrue;
			}
		}
	
	return rc;
	}

void CLocationRequestHandler::CompleteSelf(TInt aReason)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::CompleteSelf()\n");
	TRequestStatus* pStat = &iStatus;
	User::RequestComplete(pStat, aReason);
	SetActive();
	}


void CLocationRequestHandler::OnTimerEventL(TInt /*aTimerId*/)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::OnTimerEventL()\n");
	
	//Need to return to EActive state
	if(iRequestState == EActiveRestartOnTargetTime)
		{
		LBSLOG(ELogP2, "Start time occured for the LS request. Reactivate request.\n");
		InvalidateRequest();
		
		TTime timeNow;
		timeNow.UniversalTime();
		
		// TT=0 means immediate request
		TTime endTime = iRequest.TargetTime() != 0 ? iRequest.TargetTime() : iRequestActivationTime;
		endTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(endTime,iRequest.RequestQuality().MaxFixTime());
			
		if (endTime > timeNow)	// if it end in the future
			{
			iTimer->EventAtUTC(endTime, 0);
			iRequestState = EActive;
			iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonRequest);
			}
		else
			{
			LBSLOG(ELogP2, "LS or NRH request timed out.\n");
			iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonTimeout);
			}
		}
	else
		{
		LBSLOG(ELogP2, "LS or NRH request timed out.\n");
		InvalidateRequest();
		iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonTimeout);
		}
	}
	
TInt CLocationRequestHandler::RunError(TInt aError)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::RunError() Begin\n");
	// handle RunL leaving - in our case we do nothing 
	// as this means we have had encountered a program inconsistency
	// By doing nothing here  causes the main manager thread to exit
	// and the Lbs root process resolves any issues - by stopping and restarting
	// lbs components
	LBSLOG_ERR2(ELogP2, " %d \n", aError);
	
	LBSLOG(ELogP1, "CLocationRequestHandler::RunError() End\n");
 	return aError;
	}

TInt CLocationRequestHandler::OnTimerError(TInt /*aTimerId*/, TInt aError)
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::OnTimerError() Begin\n");
	// handle the same way as CLocationRequestHandler::RunError
	LBSLOG_ERR2(ELogP2, " %d \n", aError);
	LBSLOG(ELogP1, "CLocationRequestHandler::OnTimerError() End\n");
 	return aError;
	}

TBool CLocationRequestHandler::GpsTimingOfCellFramesRequested() const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::GpsTimingOfCellFramesRequested()\n");
	return iRequest.RequestMethod().GpsTimingOfCellFramesRequested();
	}


TPositionModuleInfo::TTechnologyType CLocationRequestHandler::GetTechnologyTypeFromRequest(TInt aIndex) const
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::GetTechnologyTypeFromRequest() Begin\n");
	TLbsNetPosMethodInt posMethod;
	TInt result = iRequest.RequestMethod().GetPosMethod(aIndex, posMethod);
	if (result == KErrNone)
		{
		return posMethod.PosMode();
		}
	LBSLOG(ELogP1, "CLocationRequestHandler::GetTechnologyTypeFromRequest() End\n");
	return TPositionModuleInfo::ETechnologyUnknown;
	}

	


void CLocationRequestHandler::RestartOnTargetTime()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::RestartOnTargetTime() Begin\n");
	if(iRequestState == EIdle)
		{
		__ASSERT_DEBUG(0, User::Invariant());
		LBSLOG(ELogP1, "CLocationRequestHandler::RestartOnTargetTime() End\n");
		return;
		}
	
	InvalidateRequest();
	
	TTime timeNow;
	timeNow.UniversalTime();
		
	TTime startTime = iRequest.TargetTime()==0 ? iRequestActivationTime : iRequest.TargetTime();
	//Even though it starts in the past, it is ok - it will be restarted immediately.
	iTimer->EventAtUTC(startTime, 0);  
	iRequestState = EActiveRestartOnTargetTime;
	
	LBSLOG(ELogP1, "CLocationRequestHandler::RestartOnTargetTime() End\n");
	}


void CLocationRequestHandler::CancelRestartOnTargetTime()
	{
	LBSLOG(ELogP1, "CLocationRequestHandler::CancelRestartOnTargetTime() Begin\n");
	if(iRequestState == EActiveRestartOnTargetTime)
		{
		InvalidateRequest();
			
		TTime timeNow;
		timeNow.UniversalTime();
			
		// TT=0 means immediate request
		TTime endTime = iRequest.TargetTime() != 0 ? iRequest.TargetTime() : iRequestActivationTime;
		endTime = LbsTimerUtils::AddUpInt64TimersWithOverflowCheck(endTime,iRequest.RequestQuality().MaxFixTime());
			
		if(endTime > timeNow)	// if it end in the future
			{
			iTimer->EventAtUTC(endTime, 0);
			iRequestState = EActive;
			}
		else
			{
			LBSLOG(ELogP2, "LS or NRH request timed out.\n");
			iObserver.OnLocationRequestStateChanged(iChannel, MLocationRequestHandlerObserver::EReasonTimeout);
			}
		}
		LBSLOG(ELogP1, "CLocationRequestHandler::CancelRestartOnTargetTime() End\n");
	}