// 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 "cagpsrequesthandler.h"
#include "cpositionerq.h"
#include "psylogging.h"
#include "tagpsrequestparameters.h"
#include "tpositionercall.h"
#include "agpsrequestconstants.h"

const TInt KMergeTableRows = 4;
const TInt KMergeTableColumns = 4;

const TInt KModeIndexNone = 0;
const TInt KModeIndexA = 1;
const TInt KModeIndexTB = 2;
const TInt KModeIndexTA = 3;


const TInt ModeMergeTable[KMergeTableColumns][KMergeTableRows] = 
	{
		//None			A,					TB,					TA
		{KErrGeneral,	KAutonomousMode,	KTerminalBasedMode,	KTerminalAssistedMode}, // None
		{KErrGeneral,	KAutonomousMode, 	KTerminalBasedMode,	KErrGeneral},			// A
		{KErrGeneral,	KTerminalBasedMode,	KTerminalBasedMode,	KErrGeneral},			// TB
		{KErrGeneral,	KErrGeneral,		KErrGeneral,		KTerminalAssistedMode}	// TA
	};


/**
 CRequestHandler::NewL
 Two-phased constructor.
*/
CAgpsRequestHandler* CAgpsRequestHandler::NewL(CPositionerQ* aPositionerQ)
    {
    CAgpsRequestHandler* self = new( ELeave ) CAgpsRequestHandler(aPositionerQ);
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

/*
* CAgpsRequestHandler::~CAgpsRequestHandler
* Destructor.
*/
CAgpsRequestHandler::~CAgpsRequestHandler()
    {
    TRACESTRING("CAgpsRequestHandler::~CAgpsRequestHandler()")
	// Send standby advice for first positioner
	TTracking tracking;
	IssueCancel(iPositionerQ->IterETrue(tracking), TLbsPositionUpdateRequestBase::EPowerAdviceOff);

	delete iAGPSRequestBus;
    }

/**
@param aPositionerQ	the positioner q 
*/
CAgpsRequestHandler::CAgpsRequestHandler(CPositionerQ* aPositionerQ) 
	{
	iPositionerQ = aPositionerQ;
	}

/**
construct the request bus by channel identifier
*/
void CAgpsRequestHandler::ConstructL()
	{
	CRequestHandler::ConstructL();
	
	iAGPSRequestBus = CAgpsRequestBus::NewL(KChannelArray[KAGpsManagerToLocServerChannelIndex]);

	// Send standby advice for first positioner
	TTracking tracking;
	IssueStatus(iPositionerQ->IterETrue(tracking), TLbsPositionUpdateRequestBase::EPowerAdviceStandby);
	
	User::LeaveIfError(LbsModuleInfo::GetDeviceCapabilities(KLbsGpsLocManagerUid, iCapabilities));
	}

/**
* Merges the positioning methods and checks that the requested method is
* compatible with the hardware capabiliies. Some hardware can support multiple
* modes which can be simultaneous. 
*
* @param aNewReq
*/
TInt CAgpsRequestHandler::MergeMethod(TLbsNetPosRequestMethodInt& aNewReq)
	{
	TInt error = KErrNone;
	TLbsNetPosMethodInt mergedMethod;
	TLbsNetPosMethodInt newMethod;
	
	iMergedRequest.RequestMethod().GetPosMethod(0, mergedMethod);
	aNewReq.GetPosMethod(0, newMethod);
	
	TInt mergedModeIndex = ModeToIndex(mergedMethod.PosMode());
	TInt newModeIndex	= ModeToIndex(newMethod.PosMode());
	TInt resultMode = ModeMergeTable[mergedModeIndex][newModeIndex];

		
	if(iCapabilities == TPositionModuleInfoExtended::EDeviceGpsModeSimultaneousTATB)
		{
		if(resultMode == KErrGeneral)
			{
			resultMode = KErrInUse;		
			}
		}
	else if(iCapabilities == (TPositionModuleInfoExtended::EDeviceGpsModeTerminalBased 
				| TPositionModuleInfoExtended::EDeviceGpsModeTerminalAssisted))
		{
		if(resultMode == KErrGeneral)
			{
			resultMode = KErrInUse;		
			}
		}
	else if(iCapabilities == TPositionModuleInfoExtended::EDeviceGpsModeTerminalBased)
		{
		if((resultMode == KErrGeneral) || (newModeIndex == KModeIndexTA) 
				|| (mergedModeIndex == KModeIndexTA))
			{
			resultMode = KErrCorrupt;		
			}
		}
	else if(iCapabilities == TPositionModuleInfoExtended::EDeviceGpsModeTerminalAssisted)
		{
		if((resultMode == KErrGeneral) || (newModeIndex != KModeIndexTA) 
				|| (mergedModeIndex == KModeIndexTB) || (mergedModeIndex == KModeIndexA))
			{
			resultMode = KErrCorrupt;		
			}
		}
	else
		{
		resultMode = KErrCorrupt;
		}
	
	
	if((resultMode == KAutonomousMode) 
		|| (resultMode == KTerminalBasedMode) 
		|| (resultMode == KTerminalAssistedMode))
		{
		mergedMethod.SetPosMethod(KLbsPositioningMeansGps, resultMode);
		iMergedRequest.RequestMethod().SetPosMethods(&mergedMethod, 1);
		}
	else
		{
		error = resultMode;
		}
		
	return error;
	}

/**
Merge the request with the local iMergedRequest

@param aTime The target time of the request
@param aTimeForFix The maximum fix time
@param aQuality The requested position info quality
@return KErr depending on the reason for the failure of the method merge
@see CPositionerSubSession
*/
TInt CAgpsRequestHandler::MergeRequest(const TRequestParameters* aRequestParameters, const TBool aTracking, 
							TLbsPositionUpdateRequestBase::TPowerAdvice aPower)
	{
	TPositionQuality posQuality; 
	TLbsPositionUpdateRequest newReq;
	TLbsLocRequestQuality newRequestQuality;
	const TAgpsRequestParameters* reqParams = static_cast<const TAgpsRequestParameters*>(aRequestParameters);

	reqParams->iCriteria.GetRequiredQuality(posQuality);
	
	BuildUpdateRequest(newRequestQuality, reqParams->iTimeForFix, posQuality);
	newReq.TargetTime() 	= reqParams->iTargetTime;
	
	newReq.RequestQuality().SetMaxFixTime(newRequestQuality.MaxFixTime());
	newReq.RequestQuality().SetMinHorizontalAccuracy(newRequestQuality.MinHorizontalAccuracy());
	newReq.RequestQuality().SetMinVerticalAccuracy(newRequestQuality.MinVerticalAccuracy());

	newReq.NewClient() 		= reqParams->iNewClient;
	newReq.Tracking() 		= aTracking;
	newReq.SetPowerAdvice(aPower);
	
	TLbsNetPosMethodInt mArray[1];
	mArray[0].SetPosMethod(KLbsPositioningMeansGps, reqParams->iAGPSMode);
	newReq.RequestMethod().SetPosMethods(mArray, 1);

	if(newReq.TargetTime() < iMergedRequest.TargetTime())
		{
		iMergedRequest.TargetTime() = newReq.TargetTime();
		}
		
	if(newReq.RequestQuality().MinHorizontalAccuracy() < iMergedRequest.RequestQuality().MinHorizontalAccuracy())
		{
		iMergedRequest.RequestQuality().SetMinHorizontalAccuracy(newReq.RequestQuality().MinHorizontalAccuracy());
		}
		
	if(newReq.RequestQuality().MinVerticalAccuracy() < iMergedRequest.RequestQuality().MinVerticalAccuracy())
		{
		iMergedRequest.RequestQuality().SetMinVerticalAccuracy(newReq.RequestQuality().MinVerticalAccuracy());
		}

	if(newReq.RequestQuality().MaxFixTime() < iMergedRequest.RequestQuality().MaxFixTime())
		{
		iMergedRequest.RequestQuality().SetMaxFixTime(newReq.RequestQuality().MaxFixTime());
		}
		
	iMergedRequest.NewClient() = iMergedRequest.NewClient() || newReq.NewClient();
	iMergedRequest.Tracking()  = iMergedRequest.Tracking()  || newReq.Tracking();
 
 	TLbsPositionUpdateRequest& reqNC = const_cast<TLbsPositionUpdateRequest&>(newReq);
 	iMergedRequest.SetPowerAdvice(reqNC.PowerAdvice());
 	
 	return MergeMethod(newReq.RequestMethod());
	}

/** Used before merging */
void CAgpsRequestHandler::ResetMergedRequest()
	{
	iMergedRequest.NewClient()  = EFalse;
	iMergedRequest.Tracking()   = EFalse;
	iMergedRequest.TargetTime() = KMaxTInt64;
	iMergedRequest.RequestQuality().SetMinHorizontalAccuracy(KMaxTReal32);
	iMergedRequest.RequestQuality().SetMinVerticalAccuracy(KMaxTReal32);
	iMergedRequest.RequestQuality().SetMaxFixTime(KMaxTInt64);
	TLbsNetPosMethodInt mArray[1];
	mArray[0].SetPosMethod(KLbsPositioningMeansGps, 0);
	iMergedRequest.RequestMethod().SetPosMethods(mArray, 1);
	}	

/**
Publish the request to the request bus
*/
void CAgpsRequestHandler::IssueMergedRequestL()
	{
    TRACESTRING("CAgpsRequestHandler::IssueMergedRequestL()")
	iCurrentRequest = iMergedRequest;
	TLbsPositionUpdateRequest request = iCurrentRequest;
	
	// If not tracking force the request target time to be 0,
	// the AGPS integration module manager expects this behaviour
	if (!request.Tracking())
		{
		request.TargetTime() = TTime(0);
		}
		
	iAGPSRequestBus->PublishRequestL(request);
	}
	
/**
Publish the Cancel request to the request bus.
Cancel always disables tracking (the tracking flag is EFalse by default)
*/
void CAgpsRequestHandler::IssueCancel(TBool aTracking, TLbsPositionUpdateRequestBase::TPowerAdvice aPower)
	{
	TRACESTRING("CAgpsRequestHandler::IssueCancel()")
	TLbsPositionUpdateRequestCancel cancel;

	// note, here we choose to send EPowerAdviceStandby straight away
	cancel.SetPowerAdvice(aPower);
	cancel.Tracking() = aTracking;
	
	TRAP_IGNORE(iAGPSRequestBus->PublishRequestL(cancel));
	}
	
/**
Publish statutory information (e.g tracking) to the request bus.
*/
void CAgpsRequestHandler::IssueStatus(TBool aTracking, TLbsPositionUpdateRequestBase::TPowerAdvice aPower)
   	{
   	TLbsPositionUpdateRequestStatus status;
   	status.Tracking() = aTracking;
 	status.SetPowerAdvice(aPower);
   	TRAP_IGNORE(iAGPSRequestBus->PublishRequestL(status));
   	}


TInt CAgpsRequestHandler::ModeToIndex(TInt aMode)
	{
	if(aMode == (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted))
		{
		return KModeIndexTA;
		}
	else if(aMode == (TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted))
		{
		return KModeIndexTB;
		}
	else if(aMode == TPositionModuleInfo::ETechnologyTerminal)
		{
		return KModeIndexA;
		}
	else
		{
		return KModeIndexNone;
		}
	}