// 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:

// Definition of assistance data channel component.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

#include <e32base.h>

#include <e32property.h>

#include <lbs/lbsassistancedatabase.h>

#include <lbs/lbsassistancedatabuilderset.h>

#include <lbs/lbslocerrors.h>

#include <lbserrors.h>

#include "lbsassistancedatacacheapi.h"

#include "agpschannel.h"

#include "lbsdevloggermacros.h"

#include "lbsnrhngmsgs.h"

const TLbsNetSessionIdInt KDummySessionId(TUid::Uid(0xDEADBEEF), 0xDEADBEEF);

//

// CAgpsChannel

//

CAgpsChannel::CAgpsChannel(MAgpsObserver& aObserver) : 

	CActive(EPriorityStandard),

	iSessionCompleteMsgBuffer(KDummySessionId, KErrNotFound),

	iSessionCompleteMsgValid(EFalse),

	iObserver(aObserver)

	{

	}

CAgpsChannel::~CAgpsChannel()

	{

	Cancel();

	iAssistanceDataMsgBuffer.Close();

	iAssistanceDataCache.Close();

	iAGPSChannel.Close();

	}

CAgpsChannel* CAgpsChannel::NewL(MAgpsObserver& aObserver)

	{

	CAgpsChannel* self = new (ELeave) CAgpsChannel(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CAgpsChannel::ConstructL()

	{

	CActiveScheduler::Add(this);

	iAssistanceDataMsgBuffer.OpenL();

	iAssistanceDataCache.OpenL();

	iAGPSChannel.OpenL(RLbsNetChannel::EChannelNG2AGPS, *this);

	}

void CAgpsChannel::RunL()

	{

	LBSLOG(ELogP1, "CAgpsChannel::RunL():");

	__ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Panic(KLbsNRHFault, iStatus.Int()));

	// Session Complete has higher priority

	if (iSessionCompleteMsgValid)

		{

		iAGPSChannel.SendMessage(iSessionCompleteMsgBuffer, iStatus);

		iSessionCompleteMsgValid = EFalse;

		SetActive();

		}

	else if (!iAssistanceDataMsgBuffer.IsEmpty())

		{

		TLbsNetAssistanceDataResponseMsg msg(0,0); //Empty msg

		iAssistanceDataMsgBuffer.Read(msg);

		iAGPSChannel.SendMessage(msg, iStatus);

		SetActive();

		}

	}

void CAgpsChannel::DoCancel()

	{

	iAGPSChannel.CancelSendMessageNotification();

	}

TInt CAgpsChannel::RunError(TInt aError)

	{

	return aError;

	}

void CAgpsChannel::SendAssistanceDataResponse(TInt aError, 

											  TLbsAsistanceDataGroupInt aMask, 

											  const RLbsAssistanceDataBuilderSet& aData)

	{

	LBSLOG(ELogP1, "CAgpsChannel::SendAssistanceDataResponse() CAgpsChannel::SendAssistanceDataResponse:");

	TInt err = KErrNone;

	if (aError == KErrNone)

		{

		TRAP(err, SetAssistanceDataCacheL(aData));

		__ASSERT_DEBUG(err == KErrNone, User::Panic(KLbsNRHFault, err));

		}

	else if(aError == KPositionAssistanceDataReset)

		{

		err = iAssistanceDataCache.ResetAssistanceData(aMask);

		__ASSERT_DEBUG(err == KErrNone, User::Panic(KLbsNRHFault, err));

		}

	// Do not send if writing the cache failed

	if (err == KErrNone)

		{

		TLbsNetAssistanceDataResponseMsg msg(aMask, aError);

		if (!IsActive())

			{

			LBSLOG(ELogP2, "CAgpsChannel::SendAssistanceDataResponse() iAGPSChannel.SendMessage()");

			iAGPSChannel.SendMessage(msg, iStatus);

			SetActive();

			}

		else

			{

			LBSLOG(ELogP2, "CAgpsChannel::SendAssistanceDataResponse() iAssistanceDataMsgBuffer.Write()");

			iAssistanceDataMsgBuffer.Write(msg);

			}

		}

	}

void CAgpsChannel::SendSessionComplete(TInt aReason, const TLbsNetSessionIdInt& aSessionId)

	{

	TLbsNetSessionCompleteAgpsMsg msg(aSessionId, aReason);

	if (!IsActive())

		{

		iAGPSChannel.SendMessage(msg, iStatus);

		SetActive();

		}

	else

		{

		iSessionCompleteMsgBuffer = msg;

		iSessionCompleteMsgValid = ETrue;

		}

	}

void CAgpsChannel::SetAssistanceDataCacheL(const RLbsAssistanceDataBuilderSet& aData)

	{

	RUEPositioningGpsAlmanacBuilder* almanacPtr;

	RUEPositioningGpsIonosphericModelBuilder* ionosphericPtr;

	RUEPositioningGpsNavigationModelBuilder* navigationPtr;

	RUEPositioningGpsReferenceTimeBuilder* referenceTimePtr;

	RUEPositioningGpsUtcModelBuilder*  utcPtr;

	RUEPositioningGpsAcquisitionAssistanceBuilder* acquisitionPtr;

	RBadSatListBuilder* badSatPtr;

	RReferenceLocationBuilder* referenceLocationPtr;

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

	// Check each item in turn and publish if it is valid

	// Publish the latest assistance data into the relevant properties

	if (KErrNone == data.GetDataBuilder(almanacPtr))

		{

		if (almanacPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataAlmanac, 

									   *almanacPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(acquisitionPtr))

		{

		if (acquisitionPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataAquisitionAssistance, 

									   *acquisitionPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(badSatPtr))

		{

		if (badSatPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataBadSatList, 

									   *badSatPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(navigationPtr))

		{

		if (navigationPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataNavigationModel, 

									   *navigationPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(referenceTimePtr))

		{

		if (referenceTimePtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataReferenceTime, 

									   *referenceTimePtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(ionosphericPtr))

		{

		if (ionosphericPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataIonosphericModel, 

									   *ionosphericPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(referenceLocationPtr))

		{

		if (referenceLocationPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataReferenceLocation, 

									   *referenceLocationPtr));

			}

		}

	if (KErrNone == data.GetDataBuilder(utcPtr))

		{

		if (utcPtr->IsDataAvailable())

			{

			User::LeaveIfError(iAssistanceDataCache.SetAssistDataItem(EAssistanceDataPositioningGpsUtcModel, 

									   *utcPtr));

			}

		}

	}

void CAgpsChannel::ProcessNetChannelMessage(RLbsNetChannel::TLbsNetChannelId aChannelId, const TLbsNetInternalMsgBase& aMessage)

	{

	__ASSERT_DEBUG(aChannelId == RLbsNetChannel::EChannelNG2AGPS, User::Panic(KLbsNGFault, ENGUnexpectedNetChannelId));

	(void) aChannelId;

	const TLbsNetAssistanceDataRequestMsg& msgAssReq    = static_cast<const TLbsNetAssistanceDataRequestMsg&>(aMessage);

	const TLbsNetSelfLocationRequestMsg&   msgLocReq    = static_cast<const TLbsNetSelfLocationRequestMsg&>(aMessage);

	const TLbsNetSelfLocationCancelMsg&    msgLocCancel = static_cast<const TLbsNetSelfLocationCancelMsg&>(aMessage);

	const TLbsNetSystemStatusAdviceMsg&	   msgSysStat   = static_cast<const TLbsNetSystemStatusAdviceMsg&>(aMessage);

	switch (aMessage.Type())

		{

		case TLbsNetInternalMsgBase::EAssistanceDataRequest:

			iObserver.OnAssistanceDataRequest(msgAssReq.DataRequestMask());

			break;

		case TLbsNetInternalMsgBase::ESelfLocationRequest:

			iObserver.OnSelfLocationRequest(msgLocReq.SessionId(), msgLocReq.Options());

			break;

		case TLbsNetInternalMsgBase::ESelfLocationCancel:

			iObserver.OnSelfLocationCancel(msgLocCancel.SessionId(), msgLocCancel.Reason());

			break;

		case TLbsNetInternalMsgBase::ESystemStatusAdvice:

			iObserver.OnSystemStatusAdvice(msgSysStat.Tracking());

			break;

		default:

			__ASSERT_DEBUG(EFalse, User::Panic(KLbsNGFault, ENGUnexpectedMsgType));

			break;

		}

	}

//

// RAssistanceDataMsgBuffer

//

RAssistanceDataMsgBuffer::TBufferItem::TBufferItem():

	iValid(EFalse),

	iReason(KErrNone)

	{

	}

/**

*/	

RAssistanceDataMsgBuffer::RAssistanceDataMsgBuffer():

	iBuffer(KAssistanceDataListCount),

	iEmpty(ETrue),

	iErrGeneric()

	{

	}

/**

*/	

void RAssistanceDataMsgBuffer::OpenL()

	{

	TBufferItem emptyItem;

	for (TInt i = 0; i < KAssistanceDataListCount; i++)

		{

		iBuffer.AppendL(emptyItem);

		}

	}

/**

*/

void RAssistanceDataMsgBuffer::Close()

	{

	iBuffer.Close();

	}

/**

*/	

void RAssistanceDataMsgBuffer::Write(const TLbsNetAssistanceDataResponseMsg& aMsg)

	{

	LBSLOG(ELogP1, "RAssistanceDataMsgBuffer::Write():");

	TInt reason = aMsg.Reason();

	TLbsAsistanceDataGroup mask = aMsg.DataResponseMask();

	__ASSERT_DEBUG((mask != 0) || (mask==0 && reason<0), User::Panic(KLbsNGFault, KErrArgument));

	if (EAssistanceDataNone == mask)

		{

		// assume something error code comes in

		iErrGeneric.iValid = ETrue;

		iErrGeneric.iReason = reason;

		}	

	else

		{

		for (TInt i = 0; i < KAssistanceDataListCount; i++)

			{

			if (mask & 0x01 == 0x01)

				{

				iBuffer[i].iValid  = ETrue;

				iBuffer[i].iReason = reason;

				}

			mask = mask >> 1;

			}

		}

	iEmpty = EFalse;

	}

/**

*/	

void RAssistanceDataMsgBuffer::Read(TLbsNetAssistanceDataResponseMsg& aMsg)

	{

	LBSLOG(ELogP1, "RAssistanceDataMsgBuffer::Read()"); 

	__ASSERT_DEBUG((iBuffer.Count() != 0), User::Panic(KLbsNGFault, KErrUnderflow));

	TInt reason = KErrNone;

	TInt valid = EFalse;

	TInt mask = 0;

	TInt i; //first loop

	TInt j; //second loop

	// Check error item

	if (iErrGeneric.iValid)	

		{

		mask = 0;

		reason = iErrGeneric.iReason;

		iErrGeneric.iValid = EFalse;

		iEmpty = ETrue;

		for (i = 0; i < KAssistanceDataListCount; i++)

			{

			if (iBuffer[i].iValid) 

				{

				iEmpty = EFalse;

				break;

				}

			}

		}

	else

		{

		// Find first valid item. Save the reason code

		for (i = 0; i < KAssistanceDataListCount; i++)

			{

			if (iBuffer[i].iValid) 

				{

				reason = iBuffer[i].iReason;

				break;

				}

			}

		// Find other valid items with the same reason code

		for (j = i; j < KAssistanceDataListCount; j++)

			{

			if (iBuffer[j].iValid && (iBuffer[j].iReason == reason))

				{

				mask = mask | (0x00000001 << j);

				iBuffer[j].iValid = EFalse;

				}

			valid = valid || iBuffer[j].iValid;

			}

		iEmpty = !valid;

		}

	LBSLOG2(ELogP2, "RAssistanceDataMsgBuffer::Read() iEmpty=%d", iEmpty);

	LBSLOG2(ELogP2, "RAssistanceDataMsgBuffer::Read() mask=%d", mask);

	LBSLOG2(ELogP2, "RAssistanceDataMsgBuffer::Read() reason=%d", reason);

	TLbsNetAssistanceDataResponseMsg msg(mask, reason);

	aMsg = msg;

	}

/**

*/	

TBool RAssistanceDataMsgBuffer::IsEmpty() const

	{

	return iEmpty;

	}