--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/locationmgmt/agpslocationmgr/src/lbsnetworkgatewayhandler.cpp Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,381 @@
+// 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:
+//
+
+
+#include "lbsnetworkgatewayhandler.h"
+#include "lbsassistancedatacacheapi.h"
+#include <lbs/lbsassistancealmanac.h>
+#include <lbs/lbsassistancebadsatlist.h>
+#include <lbs/lbsassistanceaquisitionassistance.h>
+#include <lbs/lbsassistancenavigationmodel.h>
+#include <lbs/lbsassistancereferencetime.h>
+#include <lbs/lbsassistanceionosphericmodel.h>
+#include <lbs/lbsassistanceutcmodel.h>
+#include <lbs/lbsassistancereferencelocation.h>
+#include "lbscommoninternaldatatypes.h"
+#include "lbsagpsngmsgs.h"
+#include "lbsdevloggermacros.h"
+#include <lbs/lbslocerrors.h>
+
+
+// We can queue up to 4 messages
+const TInt KNetworkGatewayHandlerQSize = 4;
+
+
+CNetworkGatewayHandler * CNetworkGatewayHandler::NewL
+ (
+ MNetworkGatewayHandlerObserver* aObserver
+ )
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::NewL()");
+ CNetworkGatewayHandler * self = new(ELeave) CNetworkGatewayHandler (aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+CNetworkGatewayHandler::CNetworkGatewayHandler(MNetworkGatewayHandlerObserver* aObserver) :
+ CActive(EPriorityStandard),
+ iObserver(aObserver),
+ iQ(KNetworkGatewayHandlerQSize)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::CNetworkGatewayHandler()");
+ }
+
+void CNetworkGatewayHandler::ConstructL()
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::ConstructL()");
+ CActiveScheduler::Add(this);
+ iAssistanceDataCache.OpenL();
+ iNGChannel.OpenL(RLbsNetChannel::EChannelAGPS2NG, *this);
+ iQ.OpenL();
+ }
+
+//------------------------------------------------------------------------------------------------------------
+CNetworkGatewayHandler::~CNetworkGatewayHandler()
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::~CNetworkGatewayHandler()");
+ iAssistanceDataCache.Close();
+ iNGChannel.Close();
+ iQ.Close();
+ }
+
+ // request from integration module to read a particular assistance data item
+TInt CNetworkGatewayHandler::GetAssistanceDataItem(TLbsAssistanceDataItem aItem,RDataReaderRootBase& aDataRoot, TTime& aTimeStamp)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItem()");
+ TInt error = iAssistanceDataCache.GetAssistDataItem(aItem,aDataRoot);
+ if (KErrNone == error)
+ {
+ TBool dataAvailable = EFalse;
+ switch(aItem)
+ {
+ case EAssistanceDataAquisitionAssistance:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsAcquisitionAssistanceReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataBadSatList:
+ dataAvailable = reinterpret_cast<RBadSatListReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataNavigationModel:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsNavigationModelReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataReferenceTime:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsReferenceTimeReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataIonosphericModel:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsIonosphericModelReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataReferenceLocation:
+ dataAvailable = reinterpret_cast<RReferenceLocationReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataAlmanac:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsAlmanacReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ case EAssistanceDataPositioningGpsUtcModel:
+ dataAvailable = reinterpret_cast<RUEPositioningGpsUtcModelReader*>(&aDataRoot)->IsDataAvailable();
+ break;
+ default:
+ //Intentionally empty. dataAvailable remains EFalse.
+ break;
+ }
+
+ if (!dataAvailable)
+ {
+ error = KErrNotFound;
+ }
+ else
+ {
+ aTimeStamp = aDataRoot.TimeStamp();
+ }
+ }
+ return error;
+ }
+
+// request from integration module to read a particular assistance data item time stamp only
+TInt CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp(TLbsAssistanceDataItem aItem, TTime& aTimeStamp)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp()");
+ TInt error = KErrNone;
+ TTime timeStamp;
+
+ switch(aItem)
+ {
+ case EAssistanceDataAquisitionAssistance:
+ {
+ RUEPositioningGpsAcquisitionAssistanceReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataBadSatList:
+ {
+ RBadSatListReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataNavigationModel:
+ {
+ RUEPositioningGpsNavigationModelReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataReferenceTime:
+ {
+ RUEPositioningGpsReferenceTimeReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataIonosphericModel:
+ {
+ RUEPositioningGpsIonosphericModelReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataReferenceLocation:
+ {
+ RReferenceLocationReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataAlmanac:
+ {
+ RUEPositioningGpsAlmanacReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ case EAssistanceDataPositioningGpsUtcModel:
+ {
+ RUEPositioningGpsUtcModelReader reader;
+ TRAP(error, reader.OpenL());
+ if (KErrNone == error)
+ {
+ error = GetAssistanceDataItem(aItem, reader, timeStamp);
+ reader.Close();
+ }
+ break;
+ }
+ default:
+ {
+ error = KErrNotFound;
+ break;
+ }
+ }
+
+ if (KErrNone == error)
+ {
+ aTimeStamp = timeStamp;
+ }
+
+ return error;
+ }
+
+
+// request from integration module to request a new set of assistance data from network
+void CNetworkGatewayHandler::SendAssistanceDataRequest(TLbsAsistanceDataGroup aDataItemMask)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::SendAssistanceDataRequest()");
+ TLbsNetAssistanceDataRequestMsg msg(aDataItemMask);
+ SendOrQueueMessage(msg);
+ }
+
+void CNetworkGatewayHandler::SendSelfLocationRequest(const TLbsNetSessionIdInt& aSessionId,
+ const TLbsNetPosRequestOptionsAssistanceInt& aOptions)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationRequest()");
+ TLbsNetSelfLocationRequestMsg msg(aSessionId, aOptions);
+ SendOrQueueMessage(msg);
+ }
+
+void CNetworkGatewayHandler::SendSelfLocationCancel(const TLbsNetSessionIdInt& aSessionId, TInt aReason)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationCancel()");
+ TLbsNetSelfLocationCancelMsg msg(aSessionId, aReason);
+ SendOrQueueMessage(msg);
+ }
+
+void CNetworkGatewayHandler::SendSystemStatusAdvice(TBool aTracking)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSystemStatusAdvice()");
+ TLbsNetSystemStatusAdviceMsg msg(aTracking);
+ SendOrQueueMessage(msg);
+ }
+
+void CNetworkGatewayHandler::RunL()
+ {
+ LBSLOG2(ELogP1, "CNetworkGatewayHandler::RunL() Begin. Status: %d\n", iStatus.Int());
+ __ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Panic(KLbsAGPSManFault, iStatus.Int()));
+
+ // Check if more queued messages await sending
+ if (!iQ.IsEmpty())
+ {
+ iNGChannel.SendMessage(iQ.Read(), iStatus);
+ SetActive();
+ }
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::RunL() End\n");
+ }
+
+void CNetworkGatewayHandler::DoCancel()
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::DoCancel()");
+ iNGChannel.CancelSendMessageNotification();
+ }
+
+TInt CNetworkGatewayHandler::RunError(TInt aError)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::RunError()\n");
+ LBSLOG_ERR2(ELogP2, " %d \n", aError);
+ return aError;
+ }
+
+void CNetworkGatewayHandler::SendOrQueueMessage(TLbsNetInternalMsgBase& aMsg)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::SendOrQueueMessage()\n");
+ if (!IsActive())
+ {
+ iNGChannel.SendMessage(aMsg, iStatus);
+ SetActive();
+ }
+ else
+ {
+ QueueMessage(aMsg);
+ }
+ }
+/**
+Queues messages.
+Performs implicit cancels if the queue not empty.
+Supports only one self location session at a time.
+*/
+void CNetworkGatewayHandler::QueueMessage(TLbsNetInternalMsgBase& aMsg)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::QueueMessage()\n");
+ TBool removed;
+
+ switch (aMsg.Type())
+ {
+ case TLbsNetInternalMsgBase::ESelfLocationRequest:
+ // A new request implicitly cancels a previous request and/or cancel
+ iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationRequest);
+ iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel);
+ iQ.Write(aMsg);
+ break;
+
+ case TLbsNetInternalMsgBase::ESelfLocationCancel:
+ // The AGPS manager should not send a Cancel twice
+ removed = iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel);
+ __ASSERT_DEBUG(removed == EFalse, User::Panic(KLbsAGPSManFault, KErrAlreadyExists));
+ removed = removed == removed; //dummy for UREL
+ iQ.Write(aMsg);
+ break;
+
+ case TLbsNetInternalMsgBase::EAssistanceDataRequest:
+ // It is an implicit cancel of a previous Assistance Data Request
+ iQ.FindAndRemove(TLbsNetInternalMsgBase::EAssistanceDataRequest);
+ iQ.Write(aMsg);
+ break;
+
+ case TLbsNetInternalMsgBase::ESystemStatusAdvice:
+ // It is an implicit cancel of a previous System Status Advice
+ iQ.FindAndRemove(TLbsNetInternalMsgBase::ESystemStatusAdvice);
+ iQ.Write(aMsg);
+ break;
+
+ default:
+ break;
+
+ }
+ }
+
+//---------------------------------------------------------------------------------------------------
+void CNetworkGatewayHandler::ProcessNetChannelMessage(RLbsNetChannel::TLbsNetChannelId aChannelId,
+ const TLbsNetInternalMsgBase& aMessage)
+ {
+ LBSLOG(ELogP1, "CNetworkGatewayHandler::ProcessNetChannelMessage()\n");
+ __ASSERT_DEBUG(aChannelId == RLbsNetChannel::EChannelAGPS2NG, User::Panic(KLbsAGPSManFault, EAGPSManUnexpectedNetChannelId));
+ (void) aChannelId;
+
+ const TLbsNetSessionCompleteAgpsMsg& msgComp = static_cast<const TLbsNetSessionCompleteAgpsMsg&>(aMessage);
+ const TLbsNetAssistanceDataResponseMsg& msgAss = static_cast<const TLbsNetAssistanceDataResponseMsg&>(aMessage);
+
+ switch (aMessage.Type())
+ {
+ case TLbsNetInternalMsgBase::ESessionComplete:
+ iObserver->OnSessionComplete(msgComp.Reason(), msgComp.SessionId());
+ break;
+
+ case TLbsNetInternalMsgBase::EAssistanceDataResponse:
+ iObserver->OnAssistanceDataResponse(msgAss.Reason(), msgAss.DataResponseMask());
+ break;
+
+ default:
+ LBSLOG_ERR2(ELogP2, "Unexpected message type: %d \n", aMessage.Type());
+ __ASSERT_DEBUG(EFalse, User::Panic(KLbsAGPSManFault, KErrArgument));
+ break;
+ }
+ }