datasourcemodules/gpspositioningmodule/lbsagpspsy/src/requesthandler/cagpsrequesthandler.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/datasourcemodules/gpspositioningmodule/lbsagpspsy/src/requesthandler/cagpsrequesthandler.cpp Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,315 @@
+// 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;
+ }
+ }