// 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:
// Protocol Module gateway observer class implementation
// 
//


#include "suplgatewayobserver.h"

const TInt KGatewayTimerId = 0x10101011;
const TInt KGatewayTimerDurationInMicroSec = 1000000;

CSuplGatewayObserver* CSuplGatewayObserver::NewL()
	{
	CSuplGatewayObserver* self = new (ELeave) CSuplGatewayObserver();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}


CSuplGatewayObserver::CSuplGatewayObserver()
	{
	}


CSuplGatewayObserver::~CSuplGatewayObserver()
	{
	delete iTimer;
	delete iScheduler;
	}


void CSuplGatewayObserver::ConstructL()
	{
	iScheduler = (CActiveSchedulerWait*) new CActiveSchedulerWait;
	iTimer = CLbsCallbackTimer::NewL(*this);
	SetDefaultCapabilities();
	}


void CSuplGatewayObserver::ResetWasObserverCalled()
	{
	iWasObserverCalled = EFalse;
	iCallBackResult = ENone;
	}


void CSuplGatewayObserver::WaitForCallBack()
	{
	if (!iWasObserverCalled)
		{
		iScheduler->Start();
		}
	}


void CSuplGatewayObserver::SignalObserverCallBack(const TCallBackResult aResult)
	{
	iTimer->Cancel();
	iWasObserverCalled = ETrue;
	iCallBackResult = aResult;
	if (iScheduler->IsStarted())
		{
		iScheduler->AsyncStop();
		}
	}


TBool CSuplGatewayObserver::WasObserverCalled() const
	{
	return iWasObserverCalled;
	}


TInt CSuplGatewayObserver::CallBackResult() const
	{
	return iCallBackResult;
	}


TInt CSuplGatewayObserver::AssistanceDataError() const
	{
	return iAssistanceDataError;
	}


TLbsAsistanceDataGroup CSuplGatewayObserver::AssistanceDataSetMask() const
	{
	return iAssistanceDataSetMask;
	}
	
TLbsAsistanceDataGroup CSuplGatewayObserver::AssistanceDataErrorMask() const
	{
	return iAssistanceDataErrorMask;
	}

TLbsAsistanceDataGroup CSuplGatewayObserver::ProvidedDataSetMask() const
	{
	return iProvidedDataSetMask;
	}


const TLbsNetSessionId& CSuplGatewayObserver::SessionIdValue() const
	{
	return iSessionIdValue;
	}


TInt CSuplGatewayObserver::SessionCloseReason() const
	{
	return iSessionCloseReason;
	}


TBool CSuplGatewayObserver::IsLocEmergency() const
	{
	return iLocEmergency;
	}


const MLbsNetworkProtocolObserver::TLbsNetProtocolService& CSuplGatewayObserver::LocType() const
	{
	return iLocReqType;
	}


const TLbsNetPosRequestQuality& CSuplGatewayObserver::LocQuality() const
	{
	return iLocQuality;
	}


const TPosition& CSuplGatewayObserver::ReferencePos() const
	{
	return iReferencePos;
	}


const TLbsNetPosRequestPrivacy& 
	CSuplGatewayObserver::PrivacyNotifType() const
	{
	return iPrivacyNotifType;
	}


void CSuplGatewayObserver::RequesterId(TDes8& aId) const
	{
	iRequestInfo.GetRequesterId(aId);
	}

TBool CSuplGatewayObserver::IsPrivReqReceived()
	{
	TBool ret = iPrivReqReceived;
	//Clear flag for future tests
	//(compiler won't allow to just set to EFalse)
	iPrivReqReceived = EFalse;
	return ret;
	}


void CSuplGatewayObserver::GetCurrentCapabilities(TLbsNetPosCapabilities& aCapabilities) const
	{
	aCapabilities = iCapabilities;
	}

void CSuplGatewayObserver::SetDefaultCapabilities() 
	{
	TInt numMethods = 3;
	TLbsNetPosMethod posMethods[KLbsMaxNetPosMethods];
	posMethods[0].SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal | TPositionModuleInfo::ETechnologyAssisted);
	posMethods[1].SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted);
	posMethods[2].SetPosMethod(KLbsPositioningMeansGps, TPositionModuleInfo::ETechnologyTerminal);
	TInt err = iCapabilities.SetPosMethods(posMethods, numMethods);
	}

void CSuplGatewayObserver::SetCurrentCapabilities(const TLbsNetPosCapabilities& aCapabilities)
	{
	iCapabilities = aCapabilities;
	}


void CSuplGatewayObserver::ProcessStatusUpdate(TLbsNetProtocolServiceMask /*aActiveServiceMask*/)
	{
#pragma message ("Not using ProcessStatusUpdate")
	}


void CSuplGatewayObserver::ProcessLocationRequest(const TLbsNetSessionId& aSessionId, TBool aEmergency,
	TLbsNetProtocolService aType,
	const TLbsNetPosRequestQuality& aQuality,
	const TLbsNetPosRequestMethod& aMethod)
	{
#pragma message ("Not using position request method")
	iSessionIdValue = aSessionId;
	iLocEmergency = aEmergency;
	iLocReqType = aType;
	iLocQuality = aQuality;
	iMethod = aMethod;
	SignalObserverCallBack(EProcessLocationRequest);
	}


void CSuplGatewayObserver::ProcessSessionComplete(const TLbsNetSessionId& aSessionId, TInt aReason)
	{
	iSessionIdValue = aSessionId;
	iSessionCloseReason = aReason;
	SignalObserverCallBack(EProcessSessionComplete);
	}


void CSuplGatewayObserver::ProcessAssistanceData(TLbsAsistanceDataGroup aDataMask,
			const RLbsAssistanceDataBuilderSet& aData, TInt aReason, const TLbsNetSessionIdArray& /*aSessionIdArray*/)
	{
	
	// iAssistanceDataError only stores error reasons
	// (do not store KErrNone as sometimes valid assistance data is reported
	// straigt after invalid assistance data and that would reset the error 
	// reason to KErrNone, which is not what the tests expect).
	if (aReason != KErrNone)
	{
	iAssistanceDataError = aReason;
	iAssistanceDataErrorMask = aDataMask;
	}


	if (aReason == KErrNone)
	{
	iAssistanceDataSetMask = aDataMask;

	RLbsAssistanceDataBuilderSet& localData = const_cast<RLbsAssistanceDataBuilderSet&>(aData);

	iProvidedDataSetMask = 0;
	RUEPositioningGpsAlmanacBuilder* dataItem;
	if ((KErrNone == localData.GetDataBuilder(dataItem)) &&
		(dataItem->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataAlmanac;
		}

	RBadSatListBuilder* dataItem1;
	if ((KErrNone == localData.GetDataBuilder(dataItem1)) &&
		(dataItem1->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataBadSatList;
		}

	RUEPositioningGpsIonosphericModelBuilder* dataItem2;
	if ((KErrNone == localData.GetDataBuilder(dataItem2)) &&
		(dataItem2->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataIonosphericModel;
		}

	RUEPositioningGpsNavigationModelBuilder* dataItem3;
	if ((KErrNone == localData.GetDataBuilder(dataItem3)) &&
		(dataItem3->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataNavigationModel;
		}

	RReferenceLocationBuilder* dataItem4;
	if ((KErrNone == localData.GetDataBuilder(dataItem4)) &&
		(dataItem4->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataReferenceLocation;
		}

	RUEPositioningGpsReferenceTimeBuilder* dataItem5;
	if ((KErrNone == localData.GetDataBuilder(dataItem5)) &&
		(dataItem5->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataReferenceTime;
		}

	RUEPositioningGpsUtcModelBuilder* dataItem6;
	if ((KErrNone == localData.GetDataBuilder(dataItem6)) &&
		(dataItem6->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataPositioningGpsUtcModel;
		}

	RUEPositioningGpsAcquisitionAssistanceBuilder* dataItem7;
	if ((KErrNone == localData.GetDataBuilder(dataItem7)) &&
		(dataItem7->IsDataAvailable()))
		{
		iProvidedDataSetMask |= EAssistanceDataAquisitionAssistance;
		}
	}

	SignalObserverCallBack(EProcessAssistanceData);
	}


void CSuplGatewayObserver::ProcessLocationUpdate(const TLbsNetSessionId& aSessionId, 
									const TPositionInfoBase& aLocation)
	{
	iSessionIdValue = aSessionId;
	reinterpret_cast <const TPositionInfo&> (aLocation).GetPosition(iReferencePos);
	SignalObserverCallBack(EProcessLocationUpdate);
	
	
	// When Reference Location is reported by SUPL, assistance data are reported straight
	// after, overwritting this callback's result. This flag is an additional way to remember
	// that ProcessLocationUpdate has been called and should only be checked after receiving
	// assistance data when reference location was expected.
	iRefLocNotified = ETrue;
	}


void CSuplGatewayObserver::ProcessPrivacyRequest(const TLbsNetSessionId& aSessionId, TBool /*aEmergency*/, 
									const TLbsNetPosRequestPrivacy& aNotification,
									const TLbsExternalRequestInfo& aRequestInfo)
	{
	iPrivReqReceived = ETrue;
	
	iSessionIdValue = aSessionId;
	iPrivacyNotifType = aNotification;
	iRequestInfo = aRequestInfo;
	SignalObserverCallBack(EProcessPrivacyRequest);
	}

/** Handle a timeout
*/
void CSuplGatewayObserver::OnTimerEventL(TInt aTimerId)
	{
	if (KGatewayTimerId == aTimerId)
		{
		SignalObserverCallBack(ETimeout);
		}	
	}

/** Handle a timer error
*/
TInt CSuplGatewayObserver::OnTimerError(TInt aTimerId, TInt aError)
	{
	(void)aError;
	
	if (KGatewayTimerId == aTimerId)
		{
		SignalObserverCallBack(ETimerError);
		}
	return aError;
	}

TBool CSuplGatewayObserver::IsMoreObserverActivity()
	{
	TBool ret;
	ResetWasObserverCalled();
	iTimer->EventAfter(TTimeIntervalMicroSeconds32(KGatewayTimerDurationInMicroSec),KGatewayTimerId);
	WaitForCallBack();
	ret = ETimeout == CallBackResult()? EFalse : ETrue;
	ResetWasObserverCalled();
	return ret;
	}


TBool CSuplGatewayObserver::IsRefLocNotified()
{
	return iRefLocNotified;
}