// 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:
// requesthandler.cpp
// 
//

/**
 @file
 @InternalComponent
*/

#include "crequesthandler.h"
#include "lbsdevloggermacros.h"
#include "cpositionerq.h"
#include "psylogging.h"
#include "psypanic.h"
#include "mpositioner.h"
#include "trequestparameters.h"
#include "tpositionercall.h"

/*
* CRequestHandler::~CRequestHandler
* Destructor.
*/
CRequestHandler::~CRequestHandler()
    {
	if(iPowerStandByTimer)
		{
		iPowerStandByTimer->Cancel();
		}

	delete iPowerStandByTimer;
	iPowerStandByTimer = NULL;
    }

/**
@param aModuleId Position module Id
@param aChannel Channel identifier
@param aCache A reference to lastknown position cache
*/
CRequestHandler::CRequestHandler() 
	{
	}
	
void CRequestHandler::ConstructL()
	{
	LBSLOG(ELogP1, "CRequestHandler::ConstructL()");
	iPowerStandByTimer = CLbsCallbackTimer::NewL(*this);
	ResetMergedRequest();
	}

/**
* Update the request parameters
*	
* @param aRequest The request to be updated
* @param aTimeForFix The maximum fix time
* @param aQuality The requested position info quality
*/
void CRequestHandler::BuildUpdateRequest(TLbsLocRequestQuality& aRequest, const TTimeIntervalMicroSeconds& aTimeForFix,
										const TPositionQuality& aQuality)
	{
	aRequest.SetMinHorizontalAccuracy(aQuality.HorizontalAccuracy());
	aRequest.SetMinVerticalAccuracy(aQuality.VerticalAccuracy());
	aRequest.SetMaxFixTime(aTimeForFix);
	}

/**
* Compare the current and merged requests
* 
* @ret TBool, ETrue if the current and merged requests are not the same 
*/
TBool CRequestHandler::MergedDifferent()
	{
	TBool different = EFalse;

	different = iMergedRequest.RequestQuality().MinHorizontalAccuracy() != 
				iCurrentRequest.RequestQuality().MinHorizontalAccuracy();
	different |= iMergedRequest.RequestQuality().MinVerticalAccuracy() != 
				iCurrentRequest.RequestQuality().MinVerticalAccuracy();
	different |= iMergedRequest.TargetTime() != iCurrentRequest.TargetTime();

	TLbsNetPosMethodInt mergedMethod;
	TLbsNetPosMethodInt currentMethod;
	iMergedRequest.RequestMethod().GetPosMethod(0, mergedMethod);
	iCurrentRequest.RequestMethod().GetPosMethod(0, currentMethod);
	different |= mergedMethod.PosMode() != currentMethod.PosMode();

	return different;
	}
	

/**
* Cancels the location retrieval if no outstanding requests
* Does nothing if there are outstanding requests
* @param aError, reason for cancel
*/
void CRequestHandler::CancelRequestL()
	{
	LBSLOG(ELogP1, "CRequestHandler::CancelRequestL()");
	TActiveClients active;
	if(!(iPositionerQ->IterETrue(active)))
		{
		LBSLOG(ELogP1, "No active clients. Send cancel to manager");
		TTracking tracking;
		IssueCancel(iPositionerQ->IterETrue(tracking));
		ResetMergedRequest();
		}
	LBSLOG(ELogP1, "CPositionerQ::CancelRequestL() end");
	}


/**
* Remerges any outstanding requests and Issues either new merged request if any, or issues cancel if none
* @param aError, reason for cancel
*/
void CRequestHandler::ReMergeWithCancelRequestL(TInt aError)
	{
	LBSLOG(ELogP1, "CRequestHandler::ReMergeCancelRequestL()");
	TActiveClients active;
	if(iPositionerQ->IterETrue(active))
		{
		LBSLOG(ELogP1, "Active clients");
		SubmitRequestL();
		}
	else // no outstanding requests
		{
		LBSLOG(ELogP1, "No active clients");
		if(aError != KErrTimedOut)// Don't pass to mgr if it's a LS timeout
			{
			LBSLOG(ELogP1, "Send cancel to manager");
			TTracking tracking;
			IssueCancel(iPositionerQ->IterETrue(tracking));
			}
		ResetMergedRequest();
		}
	LBSLOG(ELogP1, "CPositionerQ::ReMergeCancelRequestL() end");
	}

/**
* Triggers merging of new request
* Assumes the new request is now active so will be picked up below
*/
void CRequestHandler::SubmitNewRequestL(MPositioner* aNewRequest)
	{
	LBSLOG(ELogP1, "CRequestHandler::SubmitNewRequestL()");
	TInt newReqIndex = iPositionerQ->Index(*aNewRequest);
		
	TInt error = MergeNewRequest(newReqIndex);
	if(KErrNone == error)
		{
		if(MergedDifferent())
			{
			IssueMergedRequestL();
			
			iPowerStandByTimer->Cancel();
			}
		}
	else
		{
		aNewRequest->UpdateFailed(error);
		}
	}

TInt CRequestHandler::MergeNewRequest(TInt aNewRequest)
	{
	LBSLOG(ELogP1, "CRequestHandler::MergeNewRequest()");
	TBool active = (iPositionerQ->Positioner(aNewRequest)).IsActive();
	
	__ASSERT_DEBUG(active, User::Panic(KAdaptationPanicCategory, EPanicNewRequestInactive));

	TTracking tracking;
	TInt error = MergeRequest( (iPositionerQ->Positioner(aNewRequest)).PositionRequestParams(), 
		iPositionerQ->IterETrue(tracking), TLbsPositionUpdateRequestBase::EPowerAdviceOn );

	return error;
	}



/**
* Triggers merging of existing requests
*/
void CRequestHandler::SubmitRequestL()
	{
	LBSLOG(ELogP1, "CRequestHandler::SubmitRequestL()");
	MergeAllRequests();
		
	if(MergedDifferent())
		{
		IssueMergedRequestL();
		
		iPowerStandByTimer->Cancel();
		}
	}

/**
* Merges all active requests
*/
void CRequestHandler::MergeAllRequests()
	{
	LBSLOG(ELogP1, "CRequestHandler::MergeAllRequests()");
	ResetMergedRequest();
	
    TInt count = iPositionerQ->Count();
    for(TInt i=0; i<count; i++)
        {
        if((iPositionerQ->Positioner(i)).IsActive())
            {
   			TTracking tracking;
   			TInt error = MergeRequest( (iPositionerQ->Positioner(i)).PositionRequestParams(), iPositionerQ->IterETrue(tracking), TLbsPositionUpdateRequestBase::EPowerAdviceOn );
			__ASSERT_DEBUG(KErrNone == error, User::Panic(KAdaptationPanicCategory, EPanicModeMergeFailed));
            }
        }
	}

/**
* 
*/
void CRequestHandler::WarmDownTimerExpired()
	{
	LBSLOG(ELogP1, "CRequestHandler::WarmDownTimerExpired()");
	// Iterate positioners. If none active and no warmdown timers running, send a cancel to the manager
	TActiveClients active;
	TWarmingDownClients warmdown;
	TTracking tracking;
	
	if(!iPositionerQ->IterETrue(active) && !iPositionerQ->IterETrue(warmdown))
		{
		IssueCancel(iPositionerQ->IterETrue(tracking));
		ResetMergedRequest();
		}
	}
	
/**
* CRequestHandler::NotifyRequestComplete
* 
* Notifies the request handler that a location fix has been received 
* and recombines any outstanding requests for active positioners. This
* is because all positioners are held in the queue not just active ones.
*/
void CRequestHandler::NotifyRequestComplete()
	{
	LBSLOG(ELogP1, "CRequestHandler::NotifyRequestComplete()");
	TActiveClients active;
	if(!(iPositionerQ->IterETrue(active)))
		{
		TInactivityTimeout inactivity;

		TTimeIntervalMicroSeconds32 timeout = iPositionerQ->IterGreatest(inactivity);
		iPowerStandByTimer->Cancel();
		iPowerStandByTimer->EventAfter(timeout, EPowerStandByTimerEvent);
		ResetMergedRequest();
		}
	else
		{
		// If an error occurred sending a request then complete
		// all outstanding clients with the error code
		TRAPD(result, SubmitRequestL());
		if(result != KErrNone)
			{
			TUpdateFailed call(result);
			iPositionerQ->PositionerIterator(call);
			}
		}
	}

/**
TimeOutTimerEvent handling
*/	
void CRequestHandler::TimeOutTimerEvent()
	{
    LBSLOG(ELogP1, "CRequestHandler::TimeOutTimerEvent()");

	iPowerStandByTimer->Cancel();

	TActiveClients active;
	if(!(iPositionerQ->IterETrue(active)))
		{
		// if queue has no active positioners then send advice EPowerAdviceStandby
		TTracking tracking;
		IssueStatus(iPositionerQ->IterETrue(tracking), TLbsPositionUpdateRequestBase::EPowerAdviceStandby);
		}
	}
	
/**
TimeOutTimer error handling
*/	
TInt CRequestHandler::TimeOutTimerError(TInt /*aError*/)
	{
	return KErrNone;
	}

/**
from MLbsCallbackTimerObserver

@param aTimerId Time event ID to identify two different time events
*/
void CRequestHandler::OnTimerEventL(TInt aTimerId)	
	{
	switch(aTimerId)
		{
	case EPowerStandByTimerEvent:
		TimeOutTimerEvent();
		break;

	default:
		__ASSERT_DEBUG(0, User::Panic(KAdaptationPanicCategory, KUnknownTimerEventId));
		}
	}
/**
Timer error handling

@param aError Time error code
@param aTimerId Time event ID to identify two different time events
*/	
TInt CRequestHandler::OnTimerError(TInt aError, TInt aTimerId)
	{
	switch(aTimerId)
		{
	case EPowerStandByTimerEvent:
		TimeOutTimerError(aError);
		break;

	default:
		__ASSERT_DEBUG(0, User::Panic(KAdaptationPanicCategory, KUnknownTimerEventId));
		}
	return KErrNone; // we have handled the error locally	
	}