diff -r 000000000000 -r 667063e416a2 supl/locationomasuplprotocolhandler/protocolhandlerver2/src/epos_comasuplsession2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/supl/locationomasuplprotocolhandler/protocolhandlerver2/src/epos_comasuplsession2.cpp Tue Feb 02 01:06:48 2010 +0200 @@ -0,0 +1,5658 @@ +/* +* Copyright (c) 2002-2005 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: Implementation of Session Object in the OMA SUPL Protocol Handler +* +*/ + + + + + +#include +#include +#include +#include + +#include +#include +#include +#include // for network mode (offline) + + +#include +#include + +#include "epos_suplterminal.h" +#include "epos_suplterminalconstants.h" +#include "epos_suplterminalqop.h" + +#include "epos_comasuplnotification.h" +#include "epos_csuplprotocolmanagerbase.h" +#include "epos_csuplcommunicationmanager.h" +#include "epos_csuplconnection.h" +#include "lbs/epos_comasuplpossessionbase.h" +#include "lbs/epos_comasuplposhandlerbase.h" +#include "lbs/epos_comasuplinforequestlist.h" +#include "epos_comasupllocationid.h" +#include "epos_comasuplsessionid.h" +#include "epos_comasuplresponse.h" +#include "epos_comasuplpos.h" +#include "epos_comasuplstart.h" +#include "epos_comasupltriggeredstart.h" +#include "epos_comasuplposinit.h" +#include "epos_comasuplauthresponse.h" +#include "epos_comasupltriggeredresponse.h" +#include "epos_comasupltriggeredstop.h" +#include "epos_comasuplauthrequest.h" +#include "lbs/epos_comasuplposition.h" +#include "lbs/epos_comasuplvelocity.h" +#include "lbs/epos_comasuplsetcapabilities.h" +#include "lbs/epos_eomasuplposerrors.h" +#include "epos_comasuplinit.h" +#include "epos_csuplsettings.h" +#include "epos_csuplsettingsinternal.h" + +#include "epos_comasuplprotocolmanager2.h" +#include "epos_comasuplsettings.h" +#include "epos_comasupletelnotifier.h" +#include "epos_comasuplsession2.h" + +#include "epos_comasuplconnrequestor.h" +#include "epos_comasuplstate.h" +#include "epos_comasuplstartstate.h" +#include "epos_comasupltriggerstartstate.h" +#include "epos_comasuplposinitstate.h" +#include "epos_comasuplresponsestate.h" +#include "epos_comasupltriggerresponsestate.h" +#include "epos_comasuplendstate.h" +#include "epos_comasuplreportstate.h" +#include "epos_comasupltriggerstopstate.h" +#include "epos_comasuplposstate.h" +#include "epos_comasuplinitstate.h" +#include "epos_comasuplposrequestor.h" +#include "epos_omasuplconstants.h" +#include "epos_comasupltrace.h" +#include "epos_resourceutils.h" +#include "epos_comasupltimeouttimer.h" +#include "epos_comasupldialogtimer.h" +#include "epos_tomasuplposmethod.h" +#include "epos_omasuplconfigurationkeys.h" +#include "epos_csuplsettingparams.h" +#include "epos_comasuplasnbase.h" + + +_LIT(KTraceFileName,"SUPL_OMA_SESSION::EPos_COMASuplSession2.cpp"); + +//Multiplying factor for conversion of ellipsoid to circle +//formula used sqrt(-2*natural log(1-Confidence)) +// actual value = 1.0107676525947896431381113653917 + +//const TReal MultiplyFactorOneSigma = 1.01076765; +const TInt KMaxIntervalTime = 10; +const TInt KMaxStartTime = 10; + +// ============================ MEMBER FUNCTIONS =============================== + +//Constructor +COMASuplSession::COMASuplSession(RMobilePhone& aMobilePhone , + TOMASuplReqType aRequestType, + COMASuplPosHandlerBase *aPosHandler, + MOMASuplSessionObserver& aSessionObserver, + COMASuplSettings*& aSettings, + COMASUPLProtocolManager2 &aProtoMgr, + TInt aIpcSessionId, + COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase): + + iMobilePhone(aMobilePhone), + iRequestType(aRequestType), + iPosHandler(aPosHandler), + iHSLPAddress(aSettings->SLPAddress()), + iEncodedSuplInit(NULL), + iSessionObserver(aSessionObserver), + iSuplSettings(aSettings), + iProtocolManager(aProtoMgr), + iUIFlag(EFalse), + iSessionIDFlag(EFalse), + iRoaming(EFalse), + iChanged(EFalse), + iIpcSessionId(aIpcSessionId), + iNwInitError(EFalse), + iPersistFail(EFalse), + iCapsFail(EFalse), + iUsageDialog(EFalse), + iUsageHomeNW(EFalse), + iEtelNotify(EFalse), + iEtelRoamingCheck(EFalse), + iIapDialogShown(EFalse), + iIapDlgTimerExpired(EFalse), + iTriggerSession(EFalse), + iOMASuplAsnHandlerBaseImpl(aOMASuplAsnHandlerBase), + iTrgTimer(EFalse), + iStartTimerFlag(EFalse), + iTrgCancelRequest(EFalse), + iClientNotify(EFalse), + iDisconnected(EFalse) + + { + } + +//2 nd Phase construction + void COMASuplSession::ConstructL(CSuplCommunicationManager &aCommManager, + CSuplSettingsInternal* aSettingsStorage, + TDes& aIMSI) + { + iTrace = COMASuplTrace::NewL(); + + iTrace->Trace(_L("COMASuplSession::ConstructL"), KTraceFileName, __LINE__); + + + iConnRequestor = COMASuplConnRequestor::NewL(aCommManager,iProtocolManager,KOMASuplHSLPPort,*this); + TBuf<64> msg; + msg.Copy(_L("Port Number is :")); + msg.AppendNum(KOMASuplHSLPPort); + iTrace->Trace(msg, KTraceFileName, __LINE__); + + + iSuplStorageSettings = aSettingsStorage; + + iSuplSessionId = COMASuplSessionID::NewL(); + iCompleteSelfRequestor = COMASuplCompleteSelfRequestor::NewL(*this); + + iSETCapabilities = COMASuplSETCapabilities::NewL(); + + //All caps are on...for NET initiated case + iAllowedCapabilities = KGpsSETAssisted | KGpsSETBased | KAutonomousGps| KAFLT | KECID | KEOTD | KOTDOA | KCID; + + //Ownership transfer to iSuplSessionId + COMASuplSETSessionID* SETSessionId = COMASuplSETSessionID::NewL(); + + iSuplSessionId->SetSETSessionID(SETSessionId); + + //Ownership transfer to iSuplSessionId + iSuplSessionId->SetSLPSessionID(NULL); + + iSuplVersion.SetSuplVersion(KSuplMajorVersion,KSuplMinorVersion,KSuplRevision); + + if( aIMSI.Length() ) + { + iIMSI.Create( aIMSI ); + } + + if(iPosHandler) + { + iTrace->Trace(_L("Creating POSSession..."), KTraceFileName, __LINE__); + iPOSSession = iPosHandler->CreateNewSessionL(this); + //Don't move this statement else where + iOMASuplPOSRequestor = COMASuplPOSRequestor::NewL(this,iPOSSession); + } + else + { + iTrace->Trace(_L("No POS plugin exists..."), KTraceFileName, __LINE__); + } + + + iTimer = COMASuplTimeoutTimer::NewL(*this); + + + iIapNotifier = COMASuplIapNotifier::NewL(*this); + + + iDialogTimer = COMASuplDialogTimer::NewL(*this); + + iIsQoPPresent = EFalse; + iIsFirstPOSMessage = ETrue; + isTimeoutDialogTimerStarted = EFalse; + + iDiffTime = 0; + iSessionCompletionCode = KErrCompletion; + iClientName.CreateL(256); + iRequestorName.CreateL(256); + iRequestorName.Zero(); + iNetworkPrivacy = CPosNetworkPrivacy::NewL(); + iRequestorId = 0; + iTrace->Trace(_L("End of COMASuplSession::ConstructL"), KTraceFileName, __LINE__); + } + +// +// ----------------------------------------------------------------------------- +// COMASuplSession::NewL +// Creates new instance of COMASuplSession +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + COMASuplSession* COMASuplSession::NewL(CSuplCommunicationManager& aCommManager, + RMobilePhone& aMobilePhone, + COMASuplSettings*& aSettings, + CSuplSettingsInternal* aSettingsStorage, + TOMASuplReqType aRequestType, + MOMASuplSessionObserver& aSessionObserver, + COMASuplPosHandlerBase *aPosHandler, + TDes& aIMSI, + COMASUPLProtocolManager2 &aProtoMgr, + TInt aIpcSessionId, + COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase) + { + COMASuplSession* self = new( ELeave ) + COMASuplSession( aMobilePhone,aRequestType, aPosHandler, + aSessionObserver, aSettings, aProtoMgr, aIpcSessionId,aOMASuplAsnHandlerBase); + CleanupStack::PushL( self ); + self->ConstructL( aCommManager, aSettingsStorage, aIMSI ); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::DestroySession +// This method will delete this session..since only protocol manager will delete session object +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::DestroySession() + { + iTrace->Trace(_L("COMASuplSession::DestroySession"), KTraceFileName, __LINE__); + + //This is for sending SUPL_END if session is destroed while RunSession is going on. + if(iRequestType == ESUPL_TERMINAL && iSuplSessionState!= ESUPL_TERMINATED) + { + CancelRunSession(); + SessionEnd(); + CompleteSession(KErrCancel); + } + + delete this; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::PosPlugInUnloaded +// Handles Pos handler unload +// ----------------------------------------------------------------------------- +void COMASuplSession::PosPlugInUnloaded() + { + iTrace->Trace(_L("COMASuplSession::PosPlugInUnloaded"), KTraceFileName, __LINE__); + + // Cancel the Session + CancelSession(); + + // Delete the POS Requestor + delete iOMASuplPOSRequestor; + iOMASuplPOSRequestor = NULL; + + // Delete the POS Session + delete iPOSSession; + iPOSSession = NULL; + + if(iSuplSessionState == ESUPL_SEND) + { + CompleteSession(KErrCompletion); + } + else + { + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrCompletion); + } + } + + +//Desrtuctor + COMASuplSession::~COMASuplSession() + { + if(iTrace) + iTrace->Trace(_L("Start ~COMASuplSession::COMASuplSession"), KTraceFileName, __LINE__); + + CleanUp(); + + delete iEncodedBuffer; + delete iSuplState; + delete iOMASuplPOSRequestor; + delete iConnRequestor; + delete iSuplSessionId; + delete iCompleteSelfRequestor; + delete iDecodedAsnMessage; + delete iSETCapabilities; + delete iPosition; + delete iEncodedSuplInit; + delete iPOSSession; + iPOSSession = NULL; + delete iTimer; + delete iIapNotifier; + iIMSI.Close(); + delete iDialogTimer; + iClientName.Close(); + iRequestorName.Close(); + delete iSuplReqInfo; + delete iNetworkPrivacy; + + if(iTrace) + iTrace->Trace(_L("End of ~COMASuplSession::COMASuplSession"), KTraceFileName, __LINE__); + + delete iTrace; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::Initialize +// This method initializes the OMA SUPL Session Object +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::InitializeL(TInt aRequestID) + { + iSuplSessionState = ESUPL_INITIALIZED; + iRequestID = aRequestID; + if(iPOSSession) + { + iTrace->Trace(_L("COMASuplSession::InitializeL of POS"), KTraceFileName, __LINE__); + iOMASuplPOSRequestor->SetObserver(this); + TInt err = iOMASuplPOSRequestor->InitilizePOSSessionL(aRequestID); + if(err != KErrNone) + { + iTrace->Trace(_L("Initilization Failed ..."), KTraceFileName, __LINE__); + CompleteSession(KErrNotReady); + } + } + else + { + iTrace->Trace(_L("InitializeL, calling OperationCompleteL"), KTraceFileName, __LINE__); + OperationCompleteL(KErrNone); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CleanUp +// Perfomrs clean up operations on the OMA SUPL Session Object +// This releases any resource held by the object +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::CleanUp() + { + if(iTrace) + iTrace->Trace(_L("COMASuplSession::CleanUp"), KTraceFileName, __LINE__); + + if(iSuplState) + { + if(iSuplSessionState != ESUPL_SESSION_ERROR) + { + iSuplState->CancelOperation(); + } + } + + iConnRequestor->Cancel(); + + delete iEncodedBuffer; + iEncodedBuffer = NULL; + delete iDecodedAsnMessage; + iDecodedAsnMessage = NULL; + RemoveActiveSession(); + if(iTrace) + iTrace->Trace(_L("End of COMASuplSession::CleanUp"), KTraceFileName, __LINE__); + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::RequestType +// Returns the type of request associated with the session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +COMASuplSession::TOMASuplReqType COMASuplSession::RequestType() + { + return iRequestType; //SET OR NET + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SessionEnd +// Cleans up the session and completes +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::SessionEnd() + { + iSuplSessionState = ESUPL_TERMINATED; + + // Invoke SessionEnd on the POS Session + iTrace->Trace(_L("COMASuplSession::SessionEnd"), KTraceFileName, __LINE__); + // CleanUp + CleanUp(); + if(iPOSSession) + { + iPOSSession->SessionEnd(); + iTrace->Trace(_L("POS Session...COMASuplSession::SessionEnd."), KTraceFileName, __LINE__); + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::RunSuplSession +// Starts the SUPL Sesssion for Terminal Initiated Location Request +// The call to this method will result in the generation of SUPL START +// and sending of the SUPL START packet to the SLP. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::RunSuplSessionL(TRequestStatus& aStatus, TBool aFirstReq, const TDesC& aHslpAddress, + TBool aFallBack, TInt aAllowedCapabilities, + TInt aSessionIdSeed,TInt aRequestID) + { + iRunRequestStatus = & aStatus; + *iRunRequestStatus = KRequestPending; + + iRequestID = aRequestID; + + iTrace->Trace(_L("Start COMASuplSession::RunSuplSession"), KTraceFileName, __LINE__); + + // Log Session Id + TBuf<64> id; + id.Append(_L("Session Id is ")); + id.AppendNum(aSessionIdSeed); + iTrace->Trace(id,KTraceFileName, __LINE__); + + // Log Capability from client + id.Copy(_L("Received Capability is ")); + id.AppendNum(aAllowedCapabilities); + iTrace->Trace(id,KTraceFileName, __LINE__); + + iSETSessionUniqueId = aSessionIdSeed; + + + TInt networkMode = 1; + networkMode = GetNetworkModeL(); + + if ( networkMode == ECoreAppUIsNetworkConnectionNotAllowed ) + { + id.Copy(_L("The device is in OFFLINE mode.")); + iTrace->Trace(id,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + else + { + id.Copy(_L("The device is in ON LINE mode.")); + iTrace->Trace(id,KTraceFileName, __LINE__); + } + + if(aAllowedCapabilities == 0) + { + iAllowedCapabilities = KGpsSETAssisted | KGpsSETBased | KAutonomousGps| KAFLT | KECID | KEOTD | KOTDOA | KCID; + } + else + { + iAllowedCapabilities = aAllowedCapabilities; + } + + //Ownership transfer to iSuplSessionId + iSuplSessionId->SetSLPSessionID(NULL); + + iConnRequestor->SetDefaultParametersL(aHslpAddress,aFallBack); + + if (aFirstReq) + CheckForSuplUsageL(); + else + CheckForPreviousResultL(); + + + +// Clear Position.... + delete iPosition; + iPosition = NULL; + + + iTrace->Trace(_L("End of COMASuplSession::RunSuplSession"), KTraceFileName, __LINE__); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::RunSuplSession +// Starts the SUPL Sesssion for Terminal Initiated Location Request, with QoP +// The call to this method will result in the generation of SUPL START +// and sending of the SUPL START packet to the SLP. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::RunSuplSessionL(TRequestStatus& aStatus, TBool aFirstReq, + const TDesC& aHslpAddress, TBool aFallBack, + TInt aAllowedCapabilities,TInt aSessionIdSeed, + TSuplTerminalQop& aQop, TInt aRequestID) + { + + + iClientQop = aQop; + + TInt delay; + if(iClientQop.GetDelay(delay) != KErrNotFound) + { + iSessionStartTime.HomeTime(); + } + + iIsQoPPresent = ETrue; + RunSuplSessionL(aStatus,aFirstReq, aHslpAddress, aFallBack, aAllowedCapabilities,aSessionIdSeed,aRequestID); + } + +// ----------------------------------------------------------------------------- +// CSuplSession::RunInvalidSessionL +// Starts the SUPL Sesssion for Invalid Session ID +// Completes Self so that protocol Manager can process other stuff +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::RunInvalidSessionL(COMASuplAsnMessageBase* aDecodedMsg) + { + + // Check if the message type is SUPL END + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedMsg->MessageType(); + + if(messageType == COMASuplAsnMessageBase::ESUPL_END) + { + return; + } + + COMASuplSessionID* retrivedSessionID = NULL; + aDecodedMsg->SessionId(retrivedSessionID); + + // Set the SessionId. + UpdateSLPSessionIDL(retrivedSessionID); + UpdateSETSessionIDL(retrivedSessionID); + + //Set default slp to Conn Requestor... + iConnRequestor->UseDefaultServerL(); + + // Complete Self + iCompleteSelfRequestor->CompleteInvalidSession(); + + } + +// ----------------------------------------------------------------------------- +// CSuplSession::StartInvalidSessionL +// Starts the SUPL Sesssion for Invalid Session ID +// Generate SUPL End with error state set ti Invalid Session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::StartInvalidSessionL() + { + iTrace->Trace(_L("Start COMASuplSession::StartInvalidSessionL"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EInvalidSessionId; + GenerateSuplEndL(); + } + +// ----------------------------------------------------------------------------- +// CSuplSession::GenerateSuplMessage +// This method generates an appropriate SUPL Message based on the state +// of the SUPL object +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// + void COMASuplSession::GenerateSuplMessageL() + { + switch(iSuplSessionState) + { + //case ESUPL_INITIALIZED: + case ESUPL_CONNECTING: + { + if(iRequestType == ESUPL_TERMINAL ) + { + if (iTriggerSession) + { + if (iTrgCancelRequest) + { + iTrgCancelRequest = EFalse; + iErrorStatusCode = COMASuplEnd::EVer2SessionStopped; + GenerateSuplTriggerStopL(); + } + else if (iSuplMsgType == ESUPL_TRIG_RESPONSE || iSuplMsgType == ESUPL_REPORT) + { + GenerateSuplPosInitL(); + } + else + { + GenerateSuplTriggerStartL(); + } + } + else + GenerateSuplStartL(); + } + if(iRequestType == ESUPL_NETWORK ) + { + if (iTriggerSession) + { + if (iTrgCancelRequest) + { + iTrgCancelRequest = EFalse; + iErrorStatusCode = COMASuplEnd::EVer2SessionStopped; + GenerateSuplTriggerStopL(); + } + else if (iSuplMsgType == ESUPL_TRIG_RESPONSE || iSuplMsgType == ESUPL_REPORT) + { + GenerateSuplPosInitL(); + } + else + { + GenerateSuplTriggerStartL(); + } + } + else + GenerateSuplPosInitL(); + } + if(iRequestType == ESUPL_INVALID_SESSION ) + { + GenerateSuplEndL(); + } + + break; + } + case ESUPL_GENERATE: + { + switch(iSuplMsgType) + { + case ESUPL_RESPONSE: + case ESUPL_TRIG_RESPONSE: + case ESUPL_REPORT: + case ESUPL_INIT: + GenerateSuplPosInitL(); + break; + case ESUPL_END: + GenerateSuplEndL(); + break; + case ESUPL_POS: + GenerateSuplPosL(); + break; + case ESUPL_TRIG_STOP: + GenerateSuplTriggerStopL(); + break; + default: + // Error + break; + } + break; + } + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateSuplStart +// Generate SUPL START from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplStartL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplStartL"), KTraceFileName, __LINE__); + + // Free the existing state if any + delete iSuplState; + iSuplState = NULL; + + iSuplState = COMASuplStartState::NewL(iMobilePhone, iUT1_StartTimer,iOMASuplPOSRequestor,iOMASuplAsnHandlerBaseImpl,iAllowedCapabilities); + iSuplState->SetMsgStateObserver(this); + if(iIsQoPPresent) + { + COMASuplStartState* startSuplState = static_cast (iSuplState); + startSuplState->SetQop(iClientQop); + } + + TInt err = iSuplState->GenerateMessageL(); + iSuplMsgType = ESUPL_START; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateSuplTriggerStart +// Generate SUPL TRIGGER START from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplTriggerStartL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplTriggerStartL"), KTraceFileName, __LINE__); + + // Free the existing state if any + delete iSuplState; + iSuplState = NULL; + + iSuplState = COMASuplTriggerStartState::NewL(iMobilePhone, iUT1_StartTimer,iOMASuplPOSRequestor,iOMASuplAsnHandlerBaseImpl,iAllowedCapabilities, iTriggerParams, iRequestType); + iSuplState->SetMsgStateObserver(this); + if(iIsQoPPresent) + { + COMASuplTriggerStartState* startSuplState = static_cast (iSuplState); + startSuplState->SetQop(iClientQop); + } + + TInt err = iSuplState->GenerateMessageL(); + iSuplMsgType = ESUPL_TRIG_START; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateSuplPosInitL +// Generate SUPL POS INIT from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplPosInitL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplPosInitL"), KTraceFileName, __LINE__); + + // Free the existing state if any + iTrace->Trace(_L("Deleting SUPL State"), KTraceFileName, __LINE__); + delete iSuplState; + iSuplState = NULL; + + iTrace->Trace(_L("Setting SUPL State to NULL - successful "), KTraceFileName, __LINE__); + if(iRequestType == ESUPL_NETWORK) + { + iTrace->Trace(_L("iRequestType == ESUPL_NETWORK is true"), KTraceFileName, __LINE__); + TBuf<256> serverAddress; + HBufC8 *hslpAdress = HBufC8::NewL(256); + iConnRequestor->GetUsedServerAddress(serverAddress); + hslpAdress->Des().Copy(serverAddress); + CleanupStack::PushL(hslpAdress); + if (iTriggerSession) + { + iSuplState = COMASuplPosInitState::NewL(iSETCapabilities, iMobilePhone, iUT2_PosInitTimer, + iOMASuplPOSRequestor,iAllowedCapabilities, iRequestType, iPosMethod, iOMASuplAsnHandlerBaseImpl); + } + else + { + iSuplState = COMASuplPosInitState::NewL(iSETCapabilities, iMobilePhone, iUT2_PosInitTimer, + iOMASuplPOSRequestor,iAllowedCapabilities, iRequestType, iPosMethod, iOMASuplAsnHandlerBaseImpl,iEncodedSuplInit, hslpAdress); + } + + if(hslpAdress) + { + CleanupStack::PopAndDestroy(hslpAdress); + } + } + else + { + TBuf<128> msg(_L("COMASuplSession::GenerateSuplPosInitL() without last 2 params : ")); + msg.AppendNum(iPosMethod); + iTrace->Trace(msg, KTraceFileName, __LINE__); + iSuplState = COMASuplPosInitState::NewL(iSETCapabilities, iMobilePhone, iUT2_PosInitTimer, + iOMASuplPOSRequestor,iAllowedCapabilities,iRequestType, iPosMethod,iOMASuplAsnHandlerBaseImpl); + + } + iSuplState->SetMsgStateObserver(this); + + //If trigger session, set flag + if (iTriggerSession) + { + COMASuplPosInitState* state = static_cast (iSuplState); + state->SetTriggerSessionFlag(ETrue); + } + + iSuplState->GenerateMessageL(); + + iSuplMsgType = ESUPL_POSINIT; + + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateSuplPosL +// Generate SUPL POS from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplPosL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplPosL"), KTraceFileName, __LINE__); + + if(COMASuplState::ESUPL_POS != iSuplState->GetSuplState()) // Check if existing is of POS type. + { + COMASuplPosPayload* remainingPosPayload = GetRemainingPosPayloadL(); + delete iSuplState; + iSuplState = NULL; + iSuplState = COMASuplPosState::NewL(iPOSSession,iUT3_PosTimer,iSETCapabilities,iOMASuplAsnHandlerBaseImpl); + + COMASuplPosState* state = static_cast (iSuplState); + state->SetRemainingPosPayloadFromSuplPosInitL(remainingPosPayload);//ownership transfered to POS state class + } + + iSuplState->SetMsgStateObserver(this); + iSuplMsgType = ESUPL_POS; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + COMASuplPosState* posState = static_cast (iSuplState); + if(!(posState->IsGenerationInProgress())) + { + iSuplSessionState = ESUPL_ENCODE; + TInt err = iSuplState->GenerateMessageL(); + if(err != KErrNone) + { + iTrace->Trace(_L("COMASuplSession::GenerateSuplPosL Failed..."), KTraceFileName, __LINE__); + OperationCompleteL(err);//Error handling. + } + } + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateSuplEndL +// Generate SUPL END from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplEndL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplEnd..."), KTraceFileName, __LINE__); + + // Free the existing state if any + delete iSuplState; + iSuplState = NULL; + + if(iRequestType == ESUPL_INVALID_SESSION ) + { + iSuplSessionState = ESUPL_INITIALIZED; + } + else + { + iSuplSessionState = ESUPL_ENCODE; //Normal End + } + + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl); + iSuplState->SetMsgStateObserver(this); + iSuplMsgType = ESUPL_END; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + iSuplState->GenerateMessageL(); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GenerateTriggerStopL +// Generate SUPL END from session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GenerateSuplTriggerStopL() + { + iTrace->Trace(_L("Start of COMASuplSession::GenerateSuplTriggerStopL..."), KTraceFileName, __LINE__); + + // Free the existing state if any + delete iSuplState; + iSuplState = NULL; + + iSuplSessionState = ESUPL_ENCODE; //Normal End + + iSuplState = COMASuplTriggerStopState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl); + iSuplState->SetMsgStateObserver(this); + iSuplMsgType = ESUPL_TRIG_STOP; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + iSuplState->GenerateMessageL(); + } + +// ----------------------------------------------------------------------------- +//COMASuplSession::CompleteSession +//Informs to client about completion of location request, thro' active object + void COMASuplSession::CompleteSession(TInt aCompletionCode) + { + iTrace->Trace(_L("COMASuplSession::CompleteSession start"), KTraceFileName, __LINE__); + if(iRunRequestStatus) + { + + TTime currentTime; + currentTime.HomeTime(); + iSessionCompletionCode = aCompletionCode; + + TBuf<64> errorCode; + errorCode.Append(_L("Completing Session with error code : ")); + errorCode.AppendNum(aCompletionCode); + iTrace->Trace(errorCode, KTraceFileName, __LINE__); + + //Cell filtering is only for non-trigger requests + if (!iTriggerSession) + iConnRequestor->UpdateNetInfo(currentTime,iCurrentCellId.iMCC,iCurrentCellId.iMNC,iCurrentCellId.iCid,iCurrentCellId.iLac,iNetworkType,aCompletionCode); + + User::RequestComplete(iRunRequestStatus,aCompletionCode); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::OperationComplete +// Gets control when any of the asynchronous requests are completed +// This is a very important method and drives the OMS SUPL +// State Machine +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::OperationCompleteL(TInt aErrorCode) + { + iTrace->Trace(_L("COMASuplSession::OperationCompleteL"), KTraceFileName, __LINE__); + TBuf<128> msg; + + msg.Copy(_L("State is ")); + msg.AppendNum(iSuplSessionState); + + iTrace->Trace(msg, KTraceFileName, __LINE__); + + if(KErrNone != aErrorCode) + { + msg.Copy(_L("Actual Error Code : ")); + msg.AppendNum(aErrorCode); + iTrace->Trace(msg, KTraceFileName, __LINE__); + + if (iSuplSessionState == ESUPL_CONNECTING) + CheckForPersistentFailure(aErrorCode); + HandleSuplErrorL(aErrorCode); + return; + } + + TInt err = KErrNone; + + switch(iSuplSessionState) + { + case ESUPL_INITIALIZED: + { + if (iRequestType == ESUPL_NETWORK) + { + iIapDialogShown = ETrue; + TInt delay ; + iTrace->Trace(_L("Dialog timer not started earlier and request is NI, starting now"), KTraceFileName, __LINE__); + if (iDiffTime.Int() == 0) + { + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + msg.Copy(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + } + else + { + if (iSuplInitTimeOut > 0) + { + iTrace->Trace(_L("Delay not present in message"), KTraceFileName, __LINE__); + msg.Copy(_L("Delay value in CR is")); + msg.AppendNum(iSuplInitTimeOut); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + delay = iSuplInitTimeOut * KSecond; + } + else + { + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + } + } + else + { + msg.Copy(_L("Time diff used, diff = ")); + msg.AppendNum(iDiffTime.Int()); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + delay = iDiffTime.Int(); + } + if (iSuplMsgType == ESUPL_TRIG_RESPONSE || iSuplMsgType == ESUPL_REPORT || iDisconnected) + { + iTrace->Trace(_L("Calling CreateConnectionL() for trigger"), KTraceFileName, __LINE__); + TRAP( err, iConnRequestor->CreateConnectionL(delay, ETrue) ); + } + else + { + iTrace->Trace(_L("Calling CreateConnectionL()"), KTraceFileName, __LINE__); + TRAP( err, iConnRequestor->CreateConnectionL(delay, EFalse) ); + } + } + else //terminal initiated case + { + if (iSuplMsgType == ESUPL_TRIG_RESPONSE || iSuplMsgType == ESUPL_REPORT || iDisconnected) + { + iTrace->Trace(_L("Calling CreateConnectionL() for trigger"), KTraceFileName, __LINE__); + iDisconnected = EFalse; + TRAP( err, iConnRequestor->CreateConnectionL(ETrue) ); + } + else + { + iTrace->Trace(_L("Calling CreateConnectionL()"), KTraceFileName, __LINE__); + TRAP( err, iConnRequestor->CreateConnectionL(EFalse) ); + } + } + if(KErrNone != err) + { + HandleSuplErrorL(err); + break; + } + iSuplSessionState = ESUPL_CONNECTING; + break; + } + + case ESUPL_CONNECTING: + { + //Retrieve the portnumber being used + iPortNum = iConnRequestor->GetPortNumber(); + + if(iRequestType == ESUPL_INVALID_SESSION) + { + iTrace->Trace(_L("Handling Invalid Session..."), KTraceFileName, __LINE__); + // ::POS:: + delete iEncodedBuffer; + iEncodedBuffer = NULL; + iSuplSessionState = ESUPL_ENCODE; + iEncodedBuffer = iSuplState->EncodeMessageL(iSuplVersion, iSuplSessionId, err); + if(KErrNone == err) + { + iConnRequestor->SendPacket(*iEncodedBuffer); + iSuplSessionState = ESUPL_SEND; + } + } + else + { + GenerateSuplMessageL(); + if (iSuplMsgType != ESUPL_TRIG_STOP) + iSuplSessionState = ESUPL_GENERATE; + } + break; + } + + case ESUPL_SEND: + { + // Clean up Encoding buffer before filling it up + delete iEncodedBuffer; + iEncodedBuffer = NULL; + + if(IsWholeMessageSentL()) + { + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplSent); + } + + if( (iSuplMsgType == ESUPL_START || iSuplMsgType == ESUPL_POSINIT) && iRequestType == ESUPL_TERMINAL) // Manish : Added this to support Cell filtering... + { + COMASuplStartState* SuplStartState = static_cast (iSuplState); + SuplStartState->GetCurrentCellID(iCurrentCellId,iNetworkType); + +#ifdef PRINT_MESSAGE + + msg.Copy(_L("After receiving from SUPL START/SUPL POS INIT")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("cid=")); + msg.AppendNum(iCurrentCellId.iCid); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("Lac=")); + msg.AppendNum(iCurrentCellId.iLac); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("MCC=")); + msg.AppendNum(iCurrentCellId.iMCC); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("MNC=")); + msg.AppendNum(iCurrentCellId.iMNC); + iTrace->Trace(msg,KTraceFileName, __LINE__); +#endif + + } + + if(iPOSSession && iSuplMsgType == ESUPL_POSINIT) //Added while doing confirmance testing... + { + COMASuplPosInitState* SuplPosInitState = static_cast (iSuplState); + if(!(SuplPosInitState->IsPosPayloadPresent())) + { + iTrace->Trace(_L("StartTimer for SUPL_POSINIT..."), KTraceFileName, __LINE__); + iTimer->StartTimer(iUT2_PosInitTimer * KSecond); + } + else + { + iTrace->Trace(_L("Timer for SUPL_POSINIT not started ..since POS payload is present..."), KTraceFileName, __LINE__); + } + } + else if (iSuplMsgType == ESUPL_TRIG_STOP) + { + iTrace->Trace(_L("StartTimer for SUPL_TRIGGER_STOP..."), KTraceFileName, __LINE__); + iTimer->StartTimer(iUT2_PosInitTimer * KSecond); + } + else + { + iSuplState->StartTimer(); + } + + if(iSuplMsgType == ESUPL_END) + { + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + RemoveActiveSession(); + // Invoke Terminate Session + if (iTriggerSession && iRequestType == COMASuplSession::ESUPL_TERMINAL) + { + iTrace->Trace(_L("COMASuplSession::OperationCompleted...SUPL_END send for trigger..."), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrNone); + } + else + { + iTrace->Trace(_L("COMASuplSession::OperationCompleted...SUPL_END send for Error/cancellation..."), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrCompletion); + } + break; + } + + if( iPOSSession && + (iSuplMsgType == ESUPL_POSINIT || (iSuplMsgType == ESUPL_POS && (!IsLastPOSMessage() || IsSegmentationDone()) ) )) + { + iTrace->Trace(_L("Generating POS ..."), KTraceFileName, __LINE__); + iSuplMsgType = ESUPL_POS; + iSuplSessionState = ESUPL_GENERATE; + GenerateSuplMessageL(); + } + break; + } + + case ESUPL_GENERATE: + { + // Set the appropriate state + if(iRequestType == ESUPL_INVALID_SESSION) + { + iTrace->Trace(_L("Handling Invalid Session..."), KTraceFileName, __LINE__); + // ::POS:: + delete iEncodedBuffer; + iEncodedBuffer = NULL; + iSuplSessionState = ESUPL_ENCODE; + iEncodedBuffer = iSuplState->EncodeMessageL(iSuplVersion, iSuplSessionId, err); + if(KErrNone == err) + { + iConnRequestor->SendPacket(*iEncodedBuffer); + iSuplSessionState = ESUPL_SEND; + } + } + else + { + delete iEncodedBuffer; + iEncodedBuffer = NULL; + if(ConnectionRequired()) + { + iTrace->Trace(_L("ConnectionRequired returned TRUE"), KTraceFileName, __LINE__); + err = SetApproriateSETSessionId(); + iSuplSessionState = ESUPL_ENCODE; + CopySETCapabilities();//Copy this before and then & with Allowed Capabilities + iEncodedBuffer = iSuplState->EncodeMessageL(iSuplVersion, iSuplSessionId, err); + iConnRequestor->SendPacket(*iEncodedBuffer); + iSuplSessionState = ESUPL_SEND; + iConnRequestor->ListenToMessages(); + } + else + { + iTrace->Trace(_L("ConnectionRequired returned False"), KTraceFileName, __LINE__); + GenerateSuplMessageL(); + iSuplSessionState = ESUPL_ENCODE; + } + } + + if(KErrNone != err ) + { + HandleSuplErrorL(err); + } + break; + } + + case ESUPL_ENCODE: + { + // Clean up Encoding buffer before filling it up + delete iEncodedBuffer; + iEncodedBuffer = NULL; + + iEncodedBuffer = iSuplState->EncodeMessageL(iSuplVersion, iSuplSessionId, err); + if(KErrNone == err) + { + iConnRequestor->SendPacket(*iEncodedBuffer); + iSuplSessionState = ESUPL_SEND; + } + else + { + HandleSuplErrorL(err); + } + break; + } + + case ESUPL_RECEIVED: break; + + default: + { + HandleSuplErrorL(KErrOMAUnknownState); + break; + } + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::ConnectionRequired +// Determines of connection should be created +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool COMASuplSession::ConnectionRequired() + { + iTrace->Trace(_L("COMASuplSession::ConnectionRequired"), KTraceFileName, __LINE__); + TBuf<128> logBuf; + logBuf.Copy(_L("Trigger session ")); + if (iTriggerSession) + logBuf.Append(_L("True")); + else + logBuf.Append(_L("False")); + logBuf.Append(_L("Request type ")); + logBuf.AppendNum(iRequestType); + logBuf.Append(_L("Message type ")); + logBuf.AppendNum(iSuplMsgType); + iTrace->Trace(logBuf, KTraceFileName, __LINE__); + + { + if (iTriggerSession && iRequestType == ESUPL_TERMINAL && iSuplMsgType == ESUPL_POSINIT) + return ETrue; + } + + if(iRequestType == ESUPL_INVALID_SESSION ) + { + return ETrue; + } + if(iRequestType == ESUPL_TERMINAL && (iSuplMsgType == ESUPL_START || iSuplMsgType == ESUPL_TRIG_START)) + { + return ETrue; + } + else + { + if(iRequestType == ESUPL_NETWORK) + { + if(iSuplMsgType == ESUPL_POSINIT || iSuplMsgType == ESUPL_END || iSuplMsgType == ESUPL_TRIG_START) + { + return ETrue; + } + } + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ValidatePosition +// Validates position estimate +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt COMASuplSession::ValidatePosition(COMASuplPosition *aPosition) + { + TOMASuplUtcTime utcTime; + TOMASuplPositionEstimate pos; + + aPosition->GetPosition(utcTime, pos); + + TOMASuplPositionEstimate::TOMASuplLatitudeSign latSign; + TInt latitude; + TInt longitude; + pos.GetPositionEstimate(latSign,latitude,longitude); + + // Set Position Estimate + if(latitude < KLatitudeMin || latitude > KLatitudeMax) + { + return KErrArgument; + } + if(longitude < KLongitudeMin || longitude > KLongitudeMax) + { + return KErrArgument; + } + + // Retrieve optional parametrs of Position Estimate + // Retrieve Uncertainity + TOMASuplUncertainty uncertainty; + TInt error = pos.GetUncertainty(uncertainty); + if(!error) + { + TInt uncertSemiMajor; + TInt uncertSemiMinor; + TInt orientMajorAxis; + uncertainty.GetUncertainty(uncertSemiMajor,uncertSemiMinor,orientMajorAxis); + if(uncertSemiMajor < KUncertSemiMajorMin || uncertSemiMajor > KUncertSemiMajorMax) + { + return KErrArgument; + } + if (uncertSemiMinor < KUncertSemiMinorMin || uncertSemiMinor > KUncertSemiMinorMax) + { + return KErrArgument; + } + if (orientMajorAxis < KOrientMajorAxisMin || orientMajorAxis > KOrientMajorAxisMax) + { + return KErrArgument; + } + } + + TInt confidence; + error = pos.GetConfidence(confidence); + if(!error) + { + if(confidence < KConfidenceMin || confidence > KConfidenceMax) + { + return KErrArgument; + } + } + // Retrieve AltitudeInfo + TOMASuplAltitudeInfo altitudeInfo; + error = pos.GetAltitudeInfo(altitudeInfo); + if(!error) + { + TOMASuplAltitudeInfo::TOMASuplAltitudeDirection altDirection; + TInt altitude; + TInt altUncert; + altitudeInfo.GetAltitudeInfo(altDirection,altitude,altUncert); + if (altitude < KAltitudeMin || altitude > KAltitudeMax) + { + return KErrArgument; + } + if (altUncert < KAltitudeUncertMin || altUncert > KAltitudeUncertMax) + { + return KErrArgument; + } + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetPositionComplete +// Handles any errors that may occur during protocol processing +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::GetPositionCompleteL(TInt aError) + { + if (!iTriggerSession) + iConnRequestor->CloseConnection(); + + iPortNum = 0; + + if (iTriggerSession) + { + TPositionInfo position; + GetPosition(position); + if( iTrgFireInfo ) + { + iTrgFireInfo->Set(position); + } + if (iNumFixes == 0) + { + iTrace->Trace(_L("GetPositionComplete, last fix generation SUPL END"), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + else + { + iTrace->Trace(_L("GetPositionComplete, Completing session"), KTraceFileName, __LINE__); + CompleteSession(KErrNone); + } + } + else + { + + if(aError || iPosition->Status()) + { + delete iPosition; + iPosition = NULL; + // Invoke SessionTerminate + iTrace->Trace(_L("Could not get position from POS Msg Plugin..."), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrNone); + } + else + { + TInt err; + err = ValidatePosition(iPosition); + if (err != KErrNone) + { + delete iPosition; + iPosition = NULL; + iSessionObserver.TerminateSession(this, KErrCompletion); + } + else + iSessionObserver.TerminateSession(this, KErrNone); + } + } + } + + + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleSuplErrorL +// Handles any errors that may occur during protocol processing +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleSuplErrorL(TInt aErr) + { + // All Possible errors - + // 1. Packet generation failure + // SUPL START - Complete the session with aErr + // SUPL POS INIT - Send SUPL END with appropriate Error code + // SUPL END - Complete Session with aErr and terminate the session + // SUPL POS - Will be handled later + // 2. Secure Socket Connection failure + // Complete the Session with aErr. Terminate the supl session + // 3. Local IP Address retrieval failure + // Complete the session with aErr. Terminate the supl session + // 4. Packet Encoding error + // SUPL START - Complete Session with aErr + // SUPL POS INIT - Generate SUPL END and send to SLP + // SUPL POS - Will be handled later + // SUPL END - Complete session with aErr and terminate the session + // 5. Packet Send Error + // Complete the session with aErr and terminate the session + // 6. Unknown State Error + // SUPL START - Complete Session with invalid state + // SUPL RESPONSE - Send SUPL END with appropriate error + // SUPL POS INIT - Send SUPL END with appropriate error + // SUPL POS - Will be handled later + // SUPL END - Complete session with invalid state and terminate the session + // SUPL INTI - Will be handled later + // 7. Message Processing error + // SUPL RESPONSE - Send SUPL END with appropriate error code + // SUPL POS - Will be handled later + // SUPL END - Complete session with aErr and terminate the session + // 8. Time out Handling + // SUPL START - Send SUPL END with appropriate error code + // SUPL POS INIT - Send SUPL END with appropriate error code + // SUPL END - There should be no timer started in the first place + + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplError); + iNumFixes = 0; //Making 0 will stop all further request done by client after errors + RemoveActiveSession();//Remove session as there is error in session... + switch(iSuplSessionState) + { + + //*************************************************************************************** + + case ESUPL_INITIALIZED: //Initilization error + { + aErr = KErrNotReady; + iTrace->Trace(_L("HandleInitilizationError..."), KTraceFileName, __LINE__); + HandleInitilizationErrorL(aErr); + break; + } + + //*************************************************************************************** + + case ESUPL_CONNECTING: //Error while retriving Local IP address + { + aErr = KErrGeneral; + iTrace->Trace(_L("HandleConnectionError..."), KTraceFileName, __LINE__); + HandleConnectionErrorL(aErr); + break; + } + + //*************************************************************************************** + + case ESUPL_ENCODE: //Encoding failure error + { + + iTrace->Trace(_L("HandleEncodingError..."), KTraceFileName, __LINE__); + HandleEncodingErrorL(aErr); + break; + } + + //*************************************************************************************** + + case ESUPL_GENERATE : //Generation error + { + aErr = KErrGeneral; + iTrace->Trace(_L("HandleGenerationError..."), KTraceFileName, __LINE__); + HandleGenerationErrorL(aErr); + break; + } + + //*************************************************************************************** + + case ESUPL_SEND: //Timeout & packet send error + { + iTrace->Trace(_L("HandleSendError..."), KTraceFileName, __LINE__); + HandleSendErrorL(aErr); + break; + } + + //*************************************************************************************** + + case ESUPL_RECEIVED: //Error while getting wrong message from SLP + { + iTrace->Trace(_L("HandlePacketsError..."), KTraceFileName, __LINE__); + if (iSuplMsgType == ESUPL_REPORT) + HandleSendErrorL(aErr); + else + HandlePacketsErrorL(aErr); + break; + } + +//*************************************************************************************** + + default: + { + TBuf<64> msg(_L("Unknown ERROR occured...")); + msg.AppendNum(aErr); + iTrace->Trace(msg, KTraceFileName, __LINE__); + break; + } + + //*************************************************************************************** + } + + } + +// ----------------------------------------------------------------------------- +// ReverseString +// Reverse the string +// ----------------------------------------------------------------------------- +// +void ReverseString(TDes8& aLocalIPAddress,TInt aLength) + { + TBuf8<1> temp1; + TBuf8<1> temp2; + for(TInt i =0 ;i < aLength / 2; ++i) + { + temp1.Zero(); + temp2.Zero(); + temp1.Append(aLocalIPAddress[i]); + temp2.Append(aLocalIPAddress[aLength - 1 - i]); + aLocalIPAddress.Replace(i,1,temp2); + aLocalIPAddress.Replace(aLength - 1 - i,1,temp1); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetLocalIPAddress +// Gets Local IP address of SET +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt COMASuplSession::GetLocalIPAddress() + { + iTrace->Trace(_L("COMASuplSession::GetLocalIPAddress"), KTraceFileName, __LINE__); + + if (iSessionIDFlag) + { + return KErrNone; + } + + TInetAddr address; + TInt err = iConnRequestor->GetLocalIPAddress(address); + if (err != KErrNone) + { + return err; + } + + if ( address.Family() == KAfInet) //This routine will convert IPV4 address in TBuf8<4> + { + TUint32 ipAddress = address.Address(); + TPtr8 ptrIPAddress(reinterpret_cast(&ipAddress), + sizeof(ipAddress), sizeof(ipAddress)); + TBuf8 localIPAddress; + localIPAddress.Append(ptrIPAddress); + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID(suplSETSessionId); + ReverseString(localIPAddress,KIP4AddressLength); + suplSETSessionId->SetSuplSETSessionIDIPv4(iSETSessionUniqueId, + localIPAddress); + //#if _DEBUG + TBuf<64> msg; + TBuf<16> ipaddress; + address.Output(ipaddress); + msg.Copy(_L("Its IP4 Address. Local IP Address is ")); + msg.Append(ipaddress); + iTrace->Trace(msg,KTraceFileName, __LINE__); + //#endif + } + + if ( address.Family() == KAfInet6 ) // This routine will convert IPV6 address in TBuf8<16> + { + TBuf8 localIP6Address; + const TIp6Addr &ip6Addr = address.Ip6Address(); + for(TInt i = 0;i < 4; ++i ) + { + TUint32 ipAddress = ip6Addr.u.iAddr32[i]; + TPtr8 ptrIPAddress(reinterpret_cast(&ipAddress), + sizeof(ipAddress), sizeof(ipAddress)); + TBuf8 localIPAddress; + localIPAddress.Append(ptrIPAddress); + localIP6Address.Append(localIPAddress); + } + + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID(suplSETSessionId); + ReverseString(localIP6Address,KIP6AddressLength); + suplSETSessionId->SetSuplSETSessionIDIPv6(iSETSessionUniqueId, + localIP6Address); + //#if _DEBUG + TBuf<64> msg; + TBuf<16> ipaddress; + address.Output(ipaddress); + msg.Copy(_L("Its IP6 Address. Local IP Address is ")); + msg.Append(ipaddress); + iTrace->Trace(msg,KTraceFileName, __LINE__); + //#endif + } + + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetEncodedSuplInitL +// Sets the Encoded SUPL INIT. This is required +// to compute the VER in SUPL POS INIT +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::SetEncodedSuplInitL(HBufC8 *aEncodedSuplInit) + { + TInt len = aEncodedSuplInit->Length(); + if(iEncodedSuplInit) + { + delete iEncodedSuplInit; + iEncodedSuplInit = NULL; + } + + iEncodedSuplInit = HBufC8::NewL(len); + *iEncodedSuplInit = *aEncodedSuplInit; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SuplSessionID +// Returns SessionID of Session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +COMASuplSessionID* COMASuplSession::SuplSessionID() const + { + return iSuplSessionId; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetServerAddressL +// Gets the Server Name and returns it back to the client +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt COMASuplSession::GetServerAddressL(TDes& ahslpAddress) + { + if(iSessionCompletionCode == KErrNone) + { + iConnRequestor->GetUsedServerAddress(ahslpAddress); + iTrace->Trace(_L("Session has suceeded...returning address"), KTraceFileName, __LINE__); + iTrace->Trace(ahslpAddress, KTraceFileName, __LINE__); + return KErrNone; + } + else + { + iTrace->Trace(_L("Session has failed...returning Error"), KTraceFileName, __LINE__); + return KErrNotFound; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetPosition +// Gets the Position from the SUPL framework and returns it back to the client +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt COMASuplSession::GetPosition(TPositionInfo& aSuplPosInfo) + { + TBool aPositionQualityError=TRUE; + iTrace->Trace(_L("COMASuplSession::GetPosition(TPositionInfo)"), KTraceFileName, __LINE__); + if(!iPosition) + { + iTrace->Trace(_L("COMASuplSession::GetPosition ... Position is Empty"), KTraceFileName, __LINE__); + return KErrNotFound; + } + + TPosition posInfo; + TOMASuplUtcTime UtcTime; + TOMASuplPositionEstimate PosEstimate; + TDateTime TimeStamp; + TInt ZoneCode,Zone,altitude,AltitudeUncertainty, HorizontalAccuracy; + TOMASuplAltitudeInfo AltitudeInfo; + TInt latitude,longitude; + TOMASuplPositionEstimate::TOMASuplLatitudeSign LatSign; + TOMASuplAltitudeInfo::TOMASuplAltitudeDirection altitudeDirection; + TOMASuplUncertainty Uncertainty; + TInt UncertaintySemiMajor, UncertaintySemiMinor, OrientationMajorAxis; + TReal UncertaintySemiMajorReal, UncertaintySemiMinorReal, AltitudeUncertaintyReal; + TInt confidence; + + iPosition->GetPosition(UtcTime,PosEstimate); + UtcTime.GetUtcTime(TimeStamp,ZoneCode,Zone); + TInt altErr = PosEstimate.GetAltitudeInfo(AltitudeInfo); + PosEstimate.GetPositionEstimate(LatSign,latitude,longitude); + TInt err = PosEstimate.GetConfidence(confidence); + altitude = 0; + if (altErr == KErrNone) + AltitudeInfo.GetAltitudeInfo(altitudeDirection,altitude,AltitudeUncertainty); + + TTime time(TimeStamp); + posInfo.SetTime(time); + + if(LatSign == TOMASuplPositionEstimate::ESouth ) + { + latitude = latitude * -1; + } + + // Conversion of latitude and longitude + TReal64 newLat, newLong; + newLat = latitude; + newLong = longitude; + //Conversion as per GAD and OMA Spec + newLat = (newLat/8388608)*90; + newLong = (newLong/16777216)*360; + + if (altErr == KErrOMASuplParamNotSet) + posInfo.SetCoordinate((TReal64)newLat,(TReal64)newLong); + else + posInfo.SetCoordinate((TReal64)newLat,(TReal64)newLong,(float)altitude); + PosEstimate.GetUncertainty(Uncertainty); + Uncertainty.GetUncertainty(UncertaintySemiMajor,UncertaintySemiMinor, + OrientationMajorAxis); + TBuf<64> msg; + msg.Copy(_L("Uncertainty Semi major")); + msg.AppendNum(UncertaintySemiMajor); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Uncertainty Semi Minor")); + msg.AppendNum(UncertaintySemiMinor); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Orientation to Major axis ")); + msg.AppendNum(OrientationMajorAxis); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Altitude ")); + msg.AppendNum(altitude); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Altitude uncertainty ")); + msg.AppendNum(AltitudeUncertainty); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + // Convert uncertainty to meters + TReal pwrMjr, pwrMnr, pwrAlt; + Math::Pow(pwrMjr, 1.1, UncertaintySemiMajor); + Math::Pow(pwrMnr, 1.1, UncertaintySemiMinor); + Math::Pow(pwrAlt, 1.070000, AltitudeUncertainty); + UncertaintySemiMajorReal = 10 * (pwrMjr -1); + UncertaintySemiMinorReal = 10 * (pwrMnr -1); + AltitudeUncertaintyReal = 10 * (pwrAlt -1); + + TReal MultiplyFactor; + + // Default set accuracy values to NaN + TRealX nan; + nan.SetNaN(); + + posInfo.SetHorizontalAccuracy(nan); + posInfo.SetVerticalAccuracy(nan); + if (err == KErrOMASuplParamNotSet||confidence<=0 || confidence>=100) + { + +TReal32 horizAccr; +horizAccr = KUncertaintyConversionFactor * ( KCEP68ConversionFactor * (UncertaintySemiMajorReal + UncertaintySemiMinorReal ) ); +posInfo.SetHorizontalAccuracy(horizAccr); +if (AltitudeUncertaintyReal > 0) + posInfo.SetVerticalAccuracy(AltitudeUncertaintyReal); + + } + else + { + + TReal lnResult,a_Sigma,b_Sigma; + Math::Ln(lnResult,(1-confidence/100.0)); + Math::Sqrt(MultiplyFactor,(-2*lnResult)); + + a_Sigma=UncertaintySemiMajorReal/MultiplyFactor; + + b_Sigma=UncertaintySemiMinorReal/MultiplyFactor; + + HorizontalAccuracy=0.7542*(a_Sigma+b_Sigma); + + posInfo.SetHorizontalAccuracy(HorizontalAccuracy); + TReal32 clientHorAcc; + if(iClientQop.GetHorizontalAccuracy(clientHorAcc)!=KErrNotFound) + { + if(HorizontalAccuracy 0 && altErr == KErrNone) + { + if (confidence == 68 && AltitudeUncertaintyReal > 0) + posInfo.SetVerticalAccuracy(AltitudeUncertaintyReal); + else + { + TReal32 chiValue=0, verticalAccuracy=0; + if (confidence < 6) + { + chiValue = chisquare[1]; + } + else + { + chiValue = chisquare[confidence/5]; + } + verticalAccuracy = AltitudeUncertaintyReal/chiValue; + if (verticalAccuracy > 0) + { + posInfo.SetVerticalAccuracy(verticalAccuracy); + TReal32 clientVerAcc; + if(iClientQop.GetVerticalAccuracy(clientVerAcc)!=KErrNotFound) + { + if(verticalAccuracyTrace(_L("COMASuplSession::GetPosition(HPositionGenericInfo)"), KTraceFileName, __LINE__); + if(!iPosition) + { + iTrace->Trace(_L("COMASuplSession::GetPosition ... Position is Empty"), KTraceFileName, __LINE__); + return KErrNotFound; + } + + TRAP_IGNORE(StoreCurrentCellIDL(aSuplPosInfo)); + + TPosition posInfo; + TOMASuplUtcTime UtcTime; + TOMASuplPositionEstimate PosEstimate; + TDateTime TimeStamp; + TInt ZoneCode,Zone,altitude,AltitudeUncertainty, HorizontalAccuracy; + TOMASuplAltitudeInfo AltitudeInfo; + TInt latitude,longitude; + TOMASuplPositionEstimate::TOMASuplLatitudeSign LatSign; + TOMASuplAltitudeInfo::TOMASuplAltitudeDirection AltitudeDirection; + TOMASuplUncertainty Uncertainty; + TInt UncertaintySemiMajor, UncertaintySemiMinor, OrientationMajorAxis; + TReal UncertaintySemiMajorReal, UncertaintySemiMinorReal, AltitudeUncertaintyReal; + TInt confidence; + + iPosition->GetPosition(UtcTime,PosEstimate); + UtcTime.GetUtcTime(TimeStamp,ZoneCode,Zone); + TInt altErr = PosEstimate.GetAltitudeInfo(AltitudeInfo); + PosEstimate.GetPositionEstimate(LatSign,latitude,longitude); + TInt err = PosEstimate.GetConfidence(confidence); + altitude = 0; + if (altErr == KErrNone) + AltitudeInfo.GetAltitudeInfo(AltitudeDirection,altitude,AltitudeUncertainty); + PosEstimate.GetUncertainty(Uncertainty); + Uncertainty.GetUncertainty(UncertaintySemiMajor,UncertaintySemiMinor, + OrientationMajorAxis); + // Convert uncertainty to meters + TReal pwrMjr, pwrMnr, pwrAlt; + Math::Pow(pwrMjr, 1.1, UncertaintySemiMajor); + Math::Pow(pwrMnr, 1.1, UncertaintySemiMinor); + Math::Pow(pwrAlt, 1.070000, AltitudeUncertainty); + UncertaintySemiMajorReal = 10 * (pwrMjr -1); + UncertaintySemiMinorReal = 10 * (pwrMnr -1); + AltitudeUncertaintyReal = 10 * (pwrAlt -1); + + TReal MultiplyFactor; + + TBuf<64> msg; + msg.Copy(_L("Uncertainty Semi major")); + msg.AppendNum(UncertaintySemiMajor); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Uncertainty Semi Minor")); + msg.AppendNum(UncertaintySemiMinor); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Orientation to Major axis ")); + msg.AppendNum(OrientationMajorAxis); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Altitude ")); + msg.AppendNum(altitude); + iTrace->Trace(msg,KTraceFileName, __LINE__); + msg.Copy(_L("Altitude uncertainty ")); + msg.AppendNum(AltitudeUncertainty); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + // Default set accuracy values to NaN + TRealX nan; + nan.SetNaN(); + + posInfo.SetHorizontalAccuracy(nan); + posInfo.SetVerticalAccuracy(nan); + + if (err == KErrOMASuplParamNotSet||confidence<=0 || confidence>=100) + { + iTrace->Trace(_L("Confidance Not Set"), KTraceFileName, __LINE__); + + TReal32 horizAccr; + horizAccr = KUncertaintyConversionFactor * ( KCEP68ConversionFactor * (UncertaintySemiMajorReal + UncertaintySemiMinorReal ) ); + posInfo.SetHorizontalAccuracy(horizAccr); + if (AltitudeUncertaintyReal > 0) + posInfo.SetVerticalAccuracy(AltitudeUncertaintyReal); + } + else + { + iTrace->Trace(_L("Confidance is Set"), KTraceFileName, __LINE__); + + TReal lnResult,a_Sigma,b_Sigma; + Math::Ln(lnResult,(1-confidence/100.0)); + Math::Sqrt(MultiplyFactor,(-2*lnResult)); + + a_Sigma=UncertaintySemiMajorReal/MultiplyFactor; + b_Sigma=UncertaintySemiMinorReal/MultiplyFactor; + + HorizontalAccuracy=0.7542*(a_Sigma+b_Sigma); + + posInfo.SetHorizontalAccuracy(HorizontalAccuracy); + TReal32 clientHorAcc; + if(iClientQop.GetHorizontalAccuracy(clientHorAcc)!=KErrNotFound) + { + if(HorizontalAccuracy 0 && altErr == KErrNone) + { + if (confidence == 68 && AltitudeUncertaintyReal > 0) + posInfo.SetVerticalAccuracy(AltitudeUncertaintyReal); + else + { + TReal32 chiValue=0, verticalAccuracy=0; + if (confidence < 6) + { + chiValue = chisquare[1]; + } + else + { + chiValue = chisquare[confidence/5]; + } + verticalAccuracy = AltitudeUncertaintyReal/chiValue; + if (verticalAccuracy > 0) + { + posInfo.SetVerticalAccuracy(verticalAccuracy); + TReal32 clientVerAcc; + if(iClientQop.GetVerticalAccuracy(clientVerAcc)!=KErrNotFound) + { + if(verticalAccuracyTrace(_L("Before iPosition->GetVelocity"), KTraceFileName, __LINE__); + TInt ret = iPosition->GetVelocity(SuplVel); + iTrace->Trace(_L("After iPosition->GetVelocity"), KTraceFileName, __LINE__); + if (ret == KErrNone) + { + + VelType = SuplVel->VelType(); + + HorizVel = SuplVel->Velocity(); + + switch(VelType) + { + case EHorizVelocity: + { + iTrace->Trace(_L("Start of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizVelocity"), KTraceFileName, __LINE__); + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeed); + HorizVel->GetHorizVel(Bearing, HorSpeed); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeed, (TReal32)HorSpeed); + iTrace->Trace(_L("End of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizVelocity"), KTraceFileName, __LINE__); + break; + } + case EHorizAndVertVelocity: + { + iTrace->Trace(_L("Start of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizAndVertVelocity"), KTraceFileName, __LINE__); + COMASuplHorizAndVertVelocity* horizVertVel = (COMASuplHorizAndVertVelocity*)HorizVel; + horizVertVel->GetHorizAndVertVel(Bearing, HorSpeed, VertDirection, + VertSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeed); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeed, (TReal32)HorSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldVerticalSpeed); + aSuplPosInfo.SetValue(EPositionFieldVerticalSpeed, (TReal32)VertSpeed); + iTrace->Trace(_L("End of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizAndVertVelocity"), KTraceFileName, __LINE__); + break; + } + case EHorizUncertVelocity: + { + iTrace->Trace(_L("Start of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizUncertVelocity"), KTraceFileName, __LINE__); + COMASuplHorizUncertVelocity* horizUncertVel = (COMASuplHorizUncertVelocity*)HorizVel; + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeed); + horizUncertVel->GetHorizUncertVel(Bearing, HorSpeed, UncertSpeed); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeed, (TReal32)HorSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeedError); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeedError, (TReal32)UncertSpeed); + iTrace->Trace(_L("End of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizUncertVelocity"), KTraceFileName, __LINE__); + break; + } + case EHorizAndVertUncertVelocity: + { + iTrace->Trace(_L("Start of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizAndVertUncertVelocity"), KTraceFileName, __LINE__); + COMASuplHorizAndVertUncertVelocity* horizVertUncertVel = (COMASuplHorizAndVertUncertVelocity*)HorizVel; + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeed); + horizVertUncertVel->GetHorizVertUncertVel(Bearing, HorSpeed, + VertDirection, + VertSpeed,HorUncertSpeed,VerUncertSpeed); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeed, (TReal32)HorSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldHorizontalSpeedError); + aSuplPosInfo.SetValue(EPositionFieldHorizontalSpeedError, (TReal32)HorUncertSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldVerticalSpeed); + aSuplPosInfo.SetValue(EPositionFieldVerticalSpeed, (TReal32)VertSpeed); + aSuplPosInfo.SetRequestedField(EPositionFieldVerticalSpeedError); + aSuplPosInfo.SetValue(EPositionFieldVerticalSpeedError, (TReal32)VerUncertSpeed); + iTrace->Trace(_L("End of COMASuplSession::GetPosition(HPositionGenericInfo) velType = EHorizAndVertUncertVelocity"), KTraceFileName, __LINE__); + break; + } + } + } + TInt aClientTime; + if(iClientQop.GetDelay(aClientTime)!=KErrNotFound) + { + TTimeIntervalSeconds aDelay; + iSessionEndTime.SecondsFrom(iSessionStartTime,aDelay); + + if(aClientTime< aDelay.Int()) + aPositionQualityError=FALSE; + } + + if(aPositionQualityError==FALSE) + return KSuplPositionQualityLoss; + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleOMASuplMessage +// Handles OMA Supl messages & starts processing according to state of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleOMASuplMessageL(COMASuplAsnMessageBase* aDecodedAsnMessage,TRequestStatus& aStatus,TInt aSessionIdSeed,TInt aErrorCode) + { + delete iSuplState; + iSuplState = NULL; + + iSETSessionUniqueId = aSessionIdSeed; + iRunRequestStatus = & aStatus; + *iRunRequestStatus = KRequestPending; + + TInt networkMode = 1; + networkMode = GetNetworkModeL(); + + TBuf<64> msg; + if ( networkMode == ECoreAppUIsNetworkConnectionNotAllowed ) + { + msg.Copy(_L("The device is in OFFLINE mode.")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + else + { + msg.Copy(_L("The device is in ON LINE mode.")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + } + + CSuplSettings::TSuplSettingsUsage usage = iSuplSettings->SUPLUsage(); + + if (usage == CSuplSettings::ESuplUsageDisabled) + { + msg.Copy(_L("SUPL Usage is disabled")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedAsnMessage->MessageType(); + + if(messageType == COMASuplAsnMessageBase::ESUPL_INIT && aErrorCode == KErrNone) + { + HandleOMASuplMessageL(aDecodedAsnMessage); + } + else //Other messages than SUPL_INIT.... Send End + { + CreateCloneMessageL(aDecodedAsnMessage); + UpdateSuplSessionIDL(); + + iSuplSessionState = ESUPL_INITIALIZED; + iSuplMsgType = ESUPL_END; + + if((aErrorCode == KErrCompletion && messageType == COMASuplAsnMessageBase::ESUPL_INIT) || + (aErrorCode == KErrOMASuplOutOfRangeParameter && messageType == COMASuplAsnMessageBase::ESUPL_INIT) || + (aErrorCode == KErrOMASuplMessageLengthMismatch && messageType == COMASuplAsnMessageBase::ESUPL_INIT) || + (aErrorCode == KErrOMASuplShortFrame && messageType == COMASuplAsnMessageBase::ESUPL_INIT)) + { + iErrorStatusCode = COMASuplEnd::EUnexpectedDataValue; + if(aErrorCode == KErrOMASuplMessageLengthMismatch) + { + iErrorStatusCode = COMASuplEnd::EProtocolError; + } + if(aErrorCode == KErrOMASuplShortFrame) + { + iErrorStatusCode = COMASuplEnd::EDataMissing; + } + TInt len = iHSLPAddress.Length(); + HBufC8 *hslpAdress = NULL; + if(len > 0) + { + hslpAdress = HBufC8::NewL(iHSLPAddress.Length()); + hslpAdress->Des().Copy(iHSLPAddress); + } + + else if(len ==0) + { + iTrace->Trace(_L("Length of HSLP Address is = 0, passing the HSLP generated frm IMSI"), KTraceFileName, __LINE__); + hslpAdress = HBufC8::NewL(iSuplSettings->SLPAddressfromImsi().Length()); + CleanupStack::PushL(hslpAdress); + hslpAdress->Des().Copy(iSuplSettings->SLPAddressfromImsi()); + CleanupStack::Pop(hslpAdress); + } + CleanupStack::PushL(hslpAdress); + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl,iEncodedSuplInit,hslpAdress); + CleanupStack::PopAndDestroy(hslpAdress); + } + else + { + iErrorStatusCode = COMASuplEnd::EUnexpectedMessage; + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl); + } + + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + iSuplState->SetMsgStateObserver(this); + iSuplState->GenerateMessageL(); + iSuplSessionState = ESUPL_GENERATE; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleOMASuplMessage +// Handles OMA Supl messages & starts processing according to state of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleOMASuplMessageL(COMASuplAsnMessageBase* aDecodedAsnMessage) + { + CreateCloneMessageL(aDecodedAsnMessage); + if(CheckProtocolVersionL(aDecodedAsnMessage)) //Checks version with supported version + { + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedAsnMessage->MessageType(); + + if(messageType != COMASuplAsnMessageBase::ESUPL_POS) + { + iCompleteSelfRequestor->CompleteSelf(); //This will result in call of RequestCompleted() + } + else + { + RequestCompletedL(); + } + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::RequestCompleted +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::RequestCompletedL() + { + //Start Next Processing...... + iTrace->Trace(_L("COMASuplSession::RequestCompleted...Retriving message type"), KTraceFileName, __LINE__); + + COMASuplAsnMessageBase::TSuplMessageType messageType = iDecodedAsnMessage->MessageType(); + + switch(messageType) + { + case COMASuplAsnMessageBase::ESUPL_RESPONSE: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of SUPL_RESPONSE type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + if(iSuplMsgType == ESUPL_START) + { + iSuplMsgType = ESUPL_RESPONSE; + ProcessSuplResponseL(); + } + else + { + iTrace->Trace(_L("COMASuplSession::RequestCompletedL...Protocol Error..."), KTraceFileName, __LINE__); + // Send SUPL End with Protocol Error + HandleSuplErrorL(KErrOMASuplProtocolError); + } + break; + + } + case COMASuplAsnMessageBase::ESUPL_POS: + { + iTrace->Trace(_L("Received Message is of SUPL_POS type..."), KTraceFileName, __LINE__); + if(iOMASuplPOSRequestor) // + { + //if(((iSuplMsgType == ESUPL_POS || iSuplMsgType == ESUPL_POSINIT)) && !IsLastPOSMessage()) + if(((iSuplMsgType == ESUPL_POS || iSuplMsgType == ESUPL_POSINIT))) //Changed for SUPL_POS after UT3 + { + iSuplMsgType = ESUPL_POS; + iTimer->StopTimer(); // Added by Manish + iSuplState->StopTimer(); + ProcessSuplPosL(); + } + else + { + iSuplSessionState = ESUPL_RECEIVED; + CancelAllOperations(); + iTrace->Trace(_L("COMASuplSession::RequestCompletedL...Protocol Error..."), KTraceFileName, __LINE__); + // Send SUPL End with Protocol Error + HandleSuplErrorL(KErrOMASuplProtocolError); + } + } + else // POS is not there + { + iSuplSessionState = ESUPL_RECEIVED; + CancelAllOperations(); + iTrace->Trace(_L("COMASuplSession::RequestCompletedL...Protocol Error..."), KTraceFileName, __LINE__); + // Send SUPL End with Protocol Error + HandleSuplErrorL(KErrOMASuplProtocolError); + } + break; + } + case COMASuplAsnMessageBase::ESUPL_END: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of SUPL_END type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + //Close Connection--- Bug fix + iConnRequestor->CloseConnection(); + iPortNum = 0; + //Remove entry from Settings to inform UI that trigger session has stop + RemoveActiveSession(); + if(IsGenerationInProgress()) //Check is generation going on + { + // Invoke SessionTerminate + iSessionObserver.TerminateSession(this, KErrCompletion); + break; + } + + if(iSuplMsgType != ESUPL_END) + { + iSuplMsgType = ESUPL_END; //::POS:: + ProcessSuplEndL(); + } + break; + } + + case COMASuplAsnMessageBase::ESUPL_INIT: //::POS:: + { + iTrace->Trace(_L("Received Message is of ESUPL_INIT type..."), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_RECEIVED; + CancelAllOperations(); + iSuplMsgType = ESUPL_INIT; //::POS:: + ProcessSuplInitL(); + break; + } + + case COMASuplAsnMessageBase::ESUPL_AUTH_REQ: + case COMASuplAsnMessageBase::ESUPL_AUTH_RESP: + { + iTrace->Trace(_L("Received Message is of ESUPL_AUTH_RESPONCE/ESUPL_AUTH_REQ type..."), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_RECEIVED; + CancelAllOperations(); + iSuplMsgType = ESUPL_AUTH_RESP; + ProcessSuplAuthResponceL(); + break; + } + case COMASuplAsnMessageBase::ESUPL_TRIG_RESPONSE: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of SUPL_TRIGGER_RESPONSE type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + if(iSuplMsgType == ESUPL_TRIG_START) + { + iSuplMsgType = ESUPL_TRIG_RESPONSE; + ProcessSuplTriggerResponseL(); + //Start timer without waiting for clientNotify + if (iRequestType == ESUPL_TERMINAL) + StartPeriodicTriggerTimer(); + } + else + { + iTrace->Trace(_L("COMASuplSession::RequestCompletedL...Protocol Error..."), KTraceFileName, __LINE__); + // Send SUPL End with Protocol Error + HandleSuplErrorL(KErrOMASuplProtocolError); + } + break; + + } + + case COMASuplAsnMessageBase::ESUPL_REPORT: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of SUPL_REPORT type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + + if (iInterval > KMaxIntervalTime) + iConnRequestor->CloseConnection(); + + if(IsGenerationInProgress()) //Check is generation going on + { + // Invoke SessionTerminate + if (iRequestType != ESUPL_NETWORK) + iSessionObserver.TerminateSession(this, KErrCompletion); + break; + } + + //if(iSuplMsgType != ESUPL_REPORT) + if(iSuplMsgType == ESUPL_POS || iSuplMsgType == ESUPL_POSINIT) + { + iSuplMsgType = ESUPL_REPORT; //::POS:: + ProcessSuplReportL(); + if (iNumFixes == 0 && iRequestType == ESUPL_NETWORK) + { + iTrace->Trace(_L("StartTimer for SUPL_TRIGGER_REPORT..."), KTraceFileName, __LINE__); + iSuplState->SetMsgStateObserver(this); + iSuplState->StartTimer(); + } + + } + else + { + iTrace->Trace(_L("COMASuplSession::RequestCompletedL...Protocol Error..."), KTraceFileName, __LINE__); + // Send SUPL End with Protocol Error + HandleSuplErrorL(KErrOMASuplProtocolError); + } + /* if(iSuplMsgType != ESUPL_REPORT) + { + iSuplMsgType = ESUPL_REPORT; //::POS:: + ProcessSuplReportL(); + } */ + break; + } + case COMASuplAsnMessageBase::ESUPL_TRIG_STOP: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of SUPL_TRIGGER_STOP type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + + if(iSuplMsgType != ESUPL_TRIG_STOP) + { + iSuplMsgType = ESUPL_TRIG_STOP; //::POS:: + ProcessSuplTriggerStopL(); + } + break; + } + default: + { + iSuplSessionState = ESUPL_RECEIVED; + iTrace->Trace(_L("Received Message is of UNKNOWN type..."), KTraceFileName, __LINE__); + CancelAllOperations(); + HandleSuplErrorL(KErrOMASuplProtocolError); + break; + + } + } + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::CancelAllOperations +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::CancelAllOperations() + { + if(iSuplState) + { + iSuplState->CancelOperation(); + } + + iTrace->Trace(_L("iConnRequestor->Cancel..."), KTraceFileName, __LINE__); + iConnRequestor->Cancel(); + iTrace->Trace(_L("iCompleteSelfRequestor->Cancel..."), KTraceFileName, __LINE__); + iCompleteSelfRequestor->Cancel(); + + if(iOMASuplPOSRequestor) + iOMASuplPOSRequestor->Cancel(); + + iTrace->Trace(_L("iTimer->StopTimer..."), KTraceFileName, __LINE__); + iTimer->StopTimer(); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplResponse +// Process SUPL RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplResponseL() + { + iTrace->Trace(_L("Processing SUPL Response..."), KTraceFileName, __LINE__); + + // Recreate SUPL STATE + delete iSuplState; + iSuplState = NULL; + + iSuplState = COMASuplResponseState::NewL(); + iSuplState->SetVersion(iSuplVersion); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage); + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + iSuplMsgType = ESUPL_RESPONSE; + + iPosMethod = static_cast(iSuplState)->GetPosMethod(); + + TBuf<128> msg(_L("ProcessSuplResponseL() got iPosMethod: ")); + msg.AppendNum(iPosMethod); + iTrace->Trace(msg, KTraceFileName, __LINE__); + if(KErrNone == err) + { + iSuplSessionState = ESUPL_GENERATE; + UpdateSuplSessionIDL(); + OperationCompleteL(KErrNone); + } + else + { + HandleSuplErrorL(err); + } + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplPosL +// Process SUPL POS +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplPosL() + { + iTrace->Trace(_L("Processing SUPL Pos..."), KTraceFileName, __LINE__); + TInt error = KErrNone; + + // Recreate SUPL STATE if the previous state was not ESUPL_POS + if(iSuplState) + { + if(COMASuplState::ESUPL_POS != iSuplState->GetSuplState()) + { + delete iSuplState; + iSuplState = NULL; + + iSuplState = COMASuplPosState::NewL(iPOSSession,iUT3_PosTimer,iSETCapabilities,iOMASuplAsnHandlerBaseImpl); + } + + iSuplState->SetVersion(iSuplVersion); + error = iSuplState->ProcessMessageL(iDecodedAsnMessage); + + //This is for generating SUPL_POS, after UT3 timer started & received SUPL_POS. + + //!iIsFirstPOSMessage this is for putting new request if we + //gets SUPL_POS even if first POS message from SET failed to generate data + if( KErrNone == error && ( IsLastPOSMessage() || !iIsFirstPOSMessage )) + { + iTrace->Trace(_L("Generating POS ... After starting UT3 OR After failing of Generation of first POS message..."), KTraceFileName, __LINE__); + iSuplMsgType = ESUPL_POS; + iSuplSessionState = ESUPL_GENERATE; + GenerateSuplMessageL(); + iSuplSessionState = ESUPL_ENCODE; + } + } + + if(KErrNone != error) + { + TBuf<64> msg(_L("Error while Processing SUPL Pos is : ")); + msg.AppendNum(error); + iTrace->Trace(msg, KTraceFileName, __LINE__); + HandleSuplErrorL(error); + } + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplEndL +// Process SUPL RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplEndL() + { + iTrace->Trace(_L("COMASuplSession::ProcessSuplEndL..."), KTraceFileName, __LINE__); + + // Recreate SUPL STATE + delete iSuplState; + iSuplState = NULL; + + iSuplState = COMASuplEndState::NewL(COMASuplEnd::EUnspecified,iOMASuplAsnHandlerBaseImpl); + iSuplState->SetVersion(iSuplVersion); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage); + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + + LogEndTime(); //Log end time if QoP & delay in Qop is present. + + if(KErrOMASuplVersionNotMatching != err) //KErrNone == err)..changed for new requirement... + // Even if there is status code in SUPL_END ... still process SUPL_END + { + if(iRequestType == COMASuplSession::ESUPL_TERMINAL) + { + // if it is a trigger request, complete the + // request immediately as we don't expect position + // information in SUPL_END + if (iTriggerSession) + { + // Invoke SessionTerminate + iTriggerSession = EFalse; // reset the flag + iSessionObserver.TerminateSession(this, KErrNone); + } + else + { + // Delete Position + delete iPosition; + iPosition = NULL; + + COMASuplEndState *currState = static_cast (iSuplState); + COMASuplEnd::TOMASuplStatusCode statusCode = currState->GetStatusCode(); + + if (statusCode == COMASuplEnd::EPosMethodMismatch) + { + iFailedCaps = iAllowedCapabilities; + iCapsFail = ETrue; + } + + // Retrieve Position + COMASuplPosition *currPosition = currState->GetPosition(); + if(currPosition) //Position is in SUPL_END + { + iPosition =static_cast (currPosition->CloneL()); + + if(KErrNone == err) + { + iTrace->Trace(_L("Received SUPL_END Without Status Code"), KTraceFileName, __LINE__); + // Invoke SessionTerminate + iSessionObserver.TerminateSession(this,KErrNone); + } + else // Position & status code is present...thats why completing with KErrCompletion. + { + iTrace->Trace(_L("Received SUPL_END With Status Code"), KTraceFileName, __LINE__); + // Invoke SessionTerminate + // Changed error code as location Fw uses position if it completes with +ve value. //KErrCompletion + iSessionObserver.TerminateSession(this,KSuplPositionPresent); + } + } + else + { + if(iOMASuplPOSRequestor) + { + iPosition = COMASuplPosition::NewL(); + iOMASuplPOSRequestor->SetObserver(this); + err = iOMASuplPOSRequestor->GetPositionL(iPosition); + if(err != KErrNone) + { + delete iPosition; + iPosition = NULL; + // Invoke SessionTerminate + iSessionObserver.TerminateSession(this, err); + } + } + else //Position && iOMASuplPOSRequestor are not there + { + // Invoke SessionTerminate + iSessionObserver.TerminateSession(this, KErrNone); + } + + } + } + } + else + { + // Invoke SessionTerminate //Close session + iSessionObserver.TerminateSession(this, KErrNone); + } + } + else + { + // Handle Error + HandleSuplErrorL(err); + } + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplInitL +// Process SUPL INIT +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplInitL() + { + iTrace->Trace(_L("COMASuplSession::ProcessSuplInitL..."), KTraceFileName, __LINE__); + + TInt ret = ServerAddressCheckForSuplInitL(); + if(ret != KErrNone) + { + HandleSuplErrorL(KErrGeneral); + return; + } + + // Recreate SUPL STATE + delete iSuplState; + iSuplState = NULL; + UpdateSuplSessionIDL(); + iSuplState = COMASuplInitState::NewL(iPrivacyTimer,iHSLPAddress,*this,iSETMode,iNetworkPrivacy); + iSuplState->SetVersion(iSuplVersion); + static_cast(iSuplState)->SetSessionId(iSETSessionUniqueId); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage);//will result in PrivacyCheckCompleteL + + if (static_cast(iSuplState)->IsTriggerSession()) + { + iTriggerSession = ETrue; + iTriggerType = static_cast(iSuplState)->GetTriggerType(); + } + + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + + iPosMethod = static_cast(iSuplState)->GetPosMethod(); + + TBuf<128> msg(_L("COMASuplSession::ProcessSuplInitL() got iPosMethod : ")); + msg.AppendNum(iPosMethod); + iTrace->Trace(msg, KTraceFileName, __LINE__); + if(KErrOMASuplNoPosition == err || KErrSuplServiceNotSupported == err || + KErrOMANonProxyModeNotSupported == err ) + { + HandleSuplInitErrorL(err); + return; + } + + if(KErrNone != err) + { + HandleSuplErrorL(err); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplAuthResponceL +// Process SUPL AUTH RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplAuthResponceL() + { + // No need to create state class object for now.... + // if needed in future ... we can write it...since it will add more code which is + //equivalent to current implementation. + + delete iSuplState; + iSuplState = NULL; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); // inform to POS + HandleSuplErrorL(KErrOMASuplProtocolError); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplTriggerResponse +// Process SUPL RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplTriggerResponseL() + { + iTrace->Trace(_L("Processing SUPL Trigger Response..."), KTraceFileName, __LINE__); + + // Recreate SUPL STATE + if (iSuplState) + { + iTrace->Trace(_L("Deleting SUPL state..."), KTraceFileName, __LINE__); + delete iSuplState; + iSuplState = NULL; + } + + iTrace->Trace(_L("Creating trigger Response..."), KTraceFileName, __LINE__); + iSuplState = COMASuplTriggerResponseState::NewL(); + iTrace->Trace(_L("Setting version..."), KTraceFileName, __LINE__); + iSuplState->SetVersion(iSuplVersion); + iTrace->Trace(_L("Calling ProcessMessageL..."), KTraceFileName, __LINE__); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage); + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + iSuplMsgType = ESUPL_TRIG_RESPONSE; + + iPosMethod = static_cast(iSuplState)->GetPosMethod(); + + TBuf<128> msg(_L("ProcessSuplTriggerResponseL() got iPosMethod: ")); + msg.AppendNum(iPosMethod); + iTrace->Trace(msg, KTraceFileName, __LINE__); + + //If no error, complete request + if (iRequestType == ESUPL_NETWORK) + { + //iTrace->Trace(_L(" Calling COMASuplSession2::LaunchNotifyDialogL..."), KTraceFileName, __LINE__); + //LaunchNotifyDialogL(); + //Inform UI that ,trigger session has started... + //InsertActiveSessionL(); + TBool trgFlag = static_cast(iSuplState)->GetTriggerParamsFlag(); + + // If it is a NI request, read trigger params + if (trgFlag) + { + TOMASuplTriggerParams trgParams = static_cast(iSuplState)->GetTriggerParams(); + TOMASuplPeriodicParams perTrgParams; + trgParams.GetPeriodicParams(perTrgParams); + + perTrgParams.GetSuplPeriodicParams((TInt32&)iNumFixes, (TInt32&)iInterval); + perTrgParams.GetStartTimeSet((TInt32&)iStartTime); + iTotalNoOfFixes = iNumFixes; + iStartTimeCopy = iStartTime; + + //Close connection + if (iInterval > KMaxIntervalTime || iStartTime > KMaxStartTime) + iConnRequestor->CloseConnection(); + //For NI request, we don't get notify request + StartPeriodicTriggerTimer(); + iClientNotify = ETrue; + } + else + { + //HandleSuplErrorL(err); + iErrorStatusCode = COMASuplEnd::EDataMissing; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + } + else + { + if(KErrNone == err) + { + if(iRunRequestStatus) + { + User::RequestComplete(iRunRequestStatus,KErrNone); + } + GetPeriodicTriggerParams(); + //Inform UI that ,trigger session has started... + InsertActiveSessionL(); + //Close connection + if (iInterval > KMaxIntervalTime || iStartTime > KMaxStartTime) + iConnRequestor->CloseConnection(); + } + else + { + HandleSuplErrorL(err); + } + } + //Update session ID received in trigger response + UpdateSuplSessionIDL(); + //Inform UI that ,trigger session has started... + // InsertActiveSessionL(); + + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplReportL +// Process SUPL RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplReportL() + { + iTrace->Trace(_L("COMASuplSession::ProcessSuplReportL..."), KTraceFileName, __LINE__); + + // Recreate SUPL STATE + delete iSuplState; + iSuplState = NULL; + iTrace->Trace(_L("After state delete ProcessSuplReportL..."), KTraceFileName, __LINE__); + TBuf<32> tempBuf; + tempBuf.Append(_L("Timer Value:")); + tempBuf.AppendNum(iUT2_PosInitTimer); + iTrace->Trace(tempBuf, KTraceFileName, __LINE__); + iSuplState = COMASuplReportState::NewL(iUT2_PosInitTimer, iOMASuplAsnHandlerBaseImpl); + iSuplState->SetVersion(iSuplVersion); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage); + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + + LogEndTime(); //Log end time if QoP & delay in Qop is present. + + //Decrement number of fixes requested + iNumFixes--; + + + if(iRequestType == COMASuplSession::ESUPL_TERMINAL) + { + iTrace->Trace(_L("ProcessSuplReportL..., terminal request"), KTraceFileName, __LINE__); + // Delete Position + delete iPosition; + iPosition = NULL; + UpdateActiveTriggerSession(); //Update UI for trigger info... + COMASuplReportState *currState = static_cast (iSuplState); + // Retrieve Position + COMASuplPosition *currPosition = currState->GetPositionL(); + if(currPosition) //Position is in SUPL_REPORT for network based positioning + { + iTrace->Trace(_L("ProcessSuplReportL..., Position present"), KTraceFileName, __LINE__); + iPosition = static_cast (currPosition->CloneL()); + TPositionInfo position; + GetPosition(position); + if (iNumFixes == 0) + { + iTrace->Trace(_L("ProcessSuplReportL, last fix generation SUPL END"), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + else + { + if (iTotalNoOfFixes != iNumFixes || iClientNotify)//if this is the first fix and client notify is true then complete the request + { + iTrace->Trace(_L("ProcessSuplReportL, Completing session"), KTraceFileName, __LINE__); + if( iTrgFireInfo ) + { + iTrgFireInfo->Set(position); + } + CompleteSession(KErrNone); + } + } + } + else //Position is with POS Plugin for MS-BASED case + { + if(iOMASuplPOSRequestor) + { + iPosition = COMASuplPosition::NewL(); + iOMASuplPOSRequestor->SetObserver(this); + err = iOMASuplPOSRequestor->GetPositionL(iPosition); + if(err != KErrNone) + { + delete iPosition; + iPosition = NULL; + // Invoke SessionTerminate + if (iRequestType != ESUPL_NETWORK) + iSessionObserver.TerminateSession(this, err); + } + } + else //Position && iOMASuplPOSRequestor are not there + { + // Invoke SessionTerminate + if (iRequestType != ESUPL_NETWORK) + { + if (iNumFixes == 0) + { + iTrace->Trace(_L("ProcessSuplReportL, last fix generation SUPL END"), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + else + { + iTrace->Trace(_L("ProcessSuplReportL..., completing session"), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrNone); + } + } + } + } + //Start timer without waiting for client's Notify request + if (iNumFixes != 0) + StartPeriodicTriggerTimer(); + } + + //For NI request, we don't get notify request + if (iNumFixes != 0 && iRequestType == ESUPL_NETWORK) + { + iClientNotify = ETrue; + StartPeriodicTriggerTimer(); + LaunchNotifyDialogL(); + //UpdateActiveTriggerSession(); //Update UI for trigger info... + } + + if (iNumFixes == 0 && iRequestType == ESUPL_NETWORK) + { + LaunchNotifyDialogL(); + } +} + +// ----------------------------------------------------------------------------- +// COMASuplSession::ProcessSuplTriggerStopL +// Process SUPL RESPONSE +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::ProcessSuplTriggerStopL() + { + iTrace->Trace(_L("COMASuplSession::ProcessSuplTriggerStopL..."), KTraceFileName, __LINE__); + + // Recreate SUPL STATE + delete iSuplState; + iSuplState = NULL; + iTrace->Trace(_L("After state delete ProcessSuplTriggerStopL..."), KTraceFileName, __LINE__); + + iSuplState = COMASuplTriggerStopState::NewL(iOMASuplAsnHandlerBaseImpl); + iSuplState->SetVersion(iSuplVersion); + TInt err = iSuplState->ProcessMessageL(iDecodedAsnMessage); + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplReceived); + + LogEndTime(); //Log end time if QoP & delay in Qop is present. + + // For all requests, send SUPL END + { + iErrorStatusCode = COMASuplEnd::EVer2SessionStopped; + GenerateSuplEndL(); + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::UpdateSuplSessionIDL +// Update SLP Sesssion ID with rececived slp id. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::UpdateSuplSessionIDL() + { + iTrace->Trace(_L("COMASuplSession::UpdateSuplSessionIDL"), KTraceFileName, __LINE__); + COMASuplSessionID* retrivedSessionID = NULL; + + if(!iDecodedAsnMessage) + return; + + iDecodedAsnMessage->SessionId(retrivedSessionID); + UpdateSLPSessionIDL(retrivedSessionID); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::UpdateSessionID +// Update SLP Sesssion ID with received session ID. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::UpdateSLPSessionIDL(COMASuplSessionID *aSessionID) + { + iTrace->Trace(_L("Start of COMASuplSession::UpdateSLPSessionIDL"), KTraceFileName, __LINE__); + if(aSessionID) + { + COMASuplSLPSessionID* suplSLPID = NULL; + aSessionID->SLPSessionID(suplSLPID); + + if(suplSLPID) + { + TBuf8 sessionId; + COMASuplSLPSessionID* slpNewSessionId = COMASuplSLPSessionID::NewL(); + CleanupStack::PushL(slpNewSessionId); + COMASuplSLPAddress* slpNewIPAddress = COMASuplSLPAddress::NewL(); + CleanupStack::Pop(slpNewSessionId); + + COMASuplSLPAddress* slpIPAddress = NULL; + suplSLPID->SuplSLPSessionID(sessionId,slpIPAddress); + slpNewSessionId->SetSuplSLPSessionID(sessionId,slpNewIPAddress); + + if(slpIPAddress) + { + COMASuplSLPAddress::TSuplSLPAddressType addressType = slpIPAddress->SLPAddressType(); + if(addressType == COMASuplSLPAddress::EFqdn) + { + HBufC8* fqdn = NULL; + TInt err = slpIPAddress->Fqdn(fqdn); + if(err == KErrNone) + { + //Ownership transfer towords COMASuplSLPAddress + HBufC8* newFqdn = fqdn->AllocL(); + slpNewIPAddress->SetFqdn(newFqdn); + } + } + + if( addressType == COMASuplSLPAddress::EIPv4Address ) + { + TBuf8 ipAddress; + TInt err = slpIPAddress->IPvAddress(ipAddress); + if(err == KErrNone) + slpNewIPAddress->SetIPv4Address(ipAddress); + } + + if(addressType == COMASuplSLPAddress::EIPv6Address ) + { + TBuf8 ipAddress; + TInt err = slpIPAddress->IPvAddress(ipAddress); + if(err == KErrNone) + slpNewIPAddress->SetIPv6Address(ipAddress); + } + } + + iSuplSessionId->SetSLPSessionID(slpNewSessionId); + } + + ///////////log ////////////////// + +#if defined(_DEBUG) //This is only for logging purpose. + iTrace->Trace(_L("After UpdateSuplSessionIDL"), KTraceFileName, __LINE__); + TBuf<128> msg; + COMASuplSETSessionID* suplSETID = NULL; + iSuplSessionId->SETSessionID(suplSETID); + + COMASuplSLPSessionID* suplSlpID = NULL; + iSuplSessionId->SLPSessionID(suplSlpID); + + //SET Part + if(suplSETID) + { + msg.Copy(_L("SET Session ID : ")); + TBuf<4> id; + TInt SETSessionID; + TBuf8<32> IPvAddress8; + TBuf<32> ipAddress; + suplSETID->SuplSETSessionID(SETSessionID,IPvAddress8); + + TLex8 lex(IPvAddress8); + TChar chr; + + chr = lex.Get(); + TUint i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + + id.AppendNum(SETSessionID); + msg.Append(id); + msg.Append(_L(" IPAddress/IMSI :")); + msg.Append(ipAddress); + } + else + { + msg.Copy(_L("SET Session Id is not set.")); + } + + iTrace->Trace(msg,KTraceFileName, __LINE__); + + //SLP Part + if(suplSlpID) + { + msg.Copy(_L("SLP Session ID : ")); + TBuf8<4> sessionId8; + TBuf<32> sessionId; + TBuf8<64> ipAddress8(_L8("No Address field in SLP Session ID")); + TBuf<64> ipAddress; + + COMASuplSLPAddress* slpIPAddress = NULL; + suplSlpID->SuplSLPSessionID(sessionId8,slpIPAddress); + + if(slpIPAddress) + { + COMASuplSLPAddress::TSuplSLPAddressType addrType = slpIPAddress->SLPAddressType(); + TInt err; + HBufC8 *fqdnAddr; + + if (addrType == COMASuplSLPAddress::EFqdn) + { + iTrace->Trace(_L("SLP Address is of type FQDN"),KTraceFileName, __LINE__); + err = slpIPAddress->Fqdn(fqdnAddr); + } + else + { + iTrace->Trace(_L("SLP Address is of type IPv*"),KTraceFileName, __LINE__); + err = slpIPAddress->IPvAddress(ipAddress8); + } + + if(err != KErrNone) + { + msg.Copy(_L("SLP Address is not set.")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + return; + } + } + + TLex8 lex(ipAddress8); + TChar chr; + + chr = lex.Get(); + TUint i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + ipAddress.Append(_L(".")); + + chr = lex.Get(); + i = chr; + ipAddress.AppendNum(i); + + TLex8 lex1(sessionId8); + for(i = 0; i < 4; ++i) + { + chr = lex1.Get(); + TUint num = chr; + sessionId.Append(chr); + } + + msg.Append(sessionId); + msg.Append(_L(" IPAddress : ")); + msg.Append(ipAddress); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + } + else + { + msg.Copy(_L("SLP Session Id is not set.")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + } + +#endif + //////////////////////////////// + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::UpdateSETSessionID +// Update SET Sesssion ID with received session ID. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::UpdateSETSessionIDL(COMASuplSessionID *aSessionID) + { + + iTrace->Trace(_L("Start of COMASuplSession::UpdateSETSessionIDL"), KTraceFileName, __LINE__); + if(aSessionID) + { + COMASuplSETSessionID* retrivedSETSessionId = NULL; + aSessionID->SETSessionID(retrivedSETSessionId); + + if(retrivedSETSessionId) + { + COMASuplSETSessionID::TSuplSETIDType addressType = retrivedSETSessionId->SuplSETIDType(); + + if(addressType == COMASuplSETSessionID::EIPv4Address) + { + TInt sessionUniqueNo; + TBuf8 IPvAddress; + retrivedSETSessionId->SuplSETSessionID(sessionUniqueNo,IPvAddress); + + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID(suplSETSessionId); + suplSETSessionId->SetSuplSETSessionIDIPv4(sessionUniqueNo,IPvAddress); + iSessionIDFlag = ETrue; + } + else if(addressType == COMASuplSETSessionID::EIPv6Address) + { + TInt sessionUniqueNo; + TBuf8 IPvAddress; + retrivedSETSessionId->SuplSETSessionID(sessionUniqueNo,IPvAddress); + + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID(suplSETSessionId); + suplSETSessionId->SetSuplSETSessionIDIPv6(sessionUniqueNo,IPvAddress); + iSessionIDFlag = ETrue; + } + else // IMSI + { + TInt sessionUniqueNo; + TBuf8 IMSI; + retrivedSETSessionId->SuplSETSessionID(sessionUniqueNo, IMSI); + + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID(suplSETSessionId); + suplSETSessionId->SetSuplSETSessionIDIMSI(sessionUniqueNo, IMSI); + iSessionIDFlag = ETrue; + } + } + } + iTrace->Trace(_L("End of COMASuplSession::UpdateSETSessionIDL"), KTraceFileName, __LINE__); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CreateCloneMessageL +// Creates Clone of COMASuplAsnMessageBase +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::CreateCloneMessageL(COMASuplAsnMessageBase* aDecodedAsnMessage) + { + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL"), KTraceFileName, __LINE__); + delete iDecodedAsnMessage; + iDecodedAsnMessage = NULL; + + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedAsnMessage->MessageType(); + TInt error; + switch(messageType) + { + case COMASuplAsnMessageBase::ESUPL_START: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_START"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplStart::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_RESPONSE: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_RESPONSE"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplResponse::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_POSINIT: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_POSINIT"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplPosInit::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_POS: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : SUPL_POS"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplPos::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + + case COMASuplAsnMessageBase::ESUPL_END: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_END"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplEnd::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_INIT: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_INIT"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplInitVer2::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_AUTH_RESP: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_AUTH_RESP"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplAuthResponse::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + case COMASuplAsnMessageBase::ESUPL_AUTH_REQ: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_AUTH_RESP"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplAuthRequest::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + + case COMASuplAsnMessageBase::ESUPL_TRIG_START: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL : ESUPL_TRIG_START"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplTriggeredStart::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + + case COMASuplAsnMessageBase::ESUPL_TRIG_RESPONSE: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL:ESUPL_TRIG_RESPONSE"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplTriggeredResponse::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + + case COMASuplAsnMessageBase::ESUPL_TRIG_STOP: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL:ESUPL_TRIG_STOP"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplTriggeredStop::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + + case COMASuplAsnMessageBase::ESUPL_REPORT: + iTrace->Trace(_L("COMASuplSession::CreateCloneMessageL:ESUPL_REPORT"), KTraceFileName, __LINE__); + iDecodedAsnMessage = COMASuplReport::NewL(); + iDecodedAsnMessage->Clone(aDecodedAsnMessage,error); + break; + default: + break; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CancelSession +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::CancelSession() + { + iTrace->Trace(_L("COMASuplSession::CancelSession"), KTraceFileName, __LINE__); + CancelAllOperations(); + iConnRequestor->CancelReadOperation(); + + switch(iSuplSessionState) + { + case ESUPL_INITIALIZED: + case ESUPL_CONNECTING: + case ESUPL_SESSION_ERROR: + { + iSuplSessionState = ESUPL_SESSION_ERROR; + break; + } + + case ESUPL_RECEIVED: + { + if (iSuplMsgType == ESUPL_TRIG_RESPONSE) + { + } + else + { + iSuplSessionState = ESUPL_SESSION_ERROR; + if(iSuplMsgType == ESUPL_END) + { + if(iOMASuplPOSRequestor) + iOMASuplPOSRequestor->Cancel(); + } + } + break; + } + + case ESUPL_GENERATE: + case ESUPL_ENCODE: + { + if(iSuplMsgType == ESUPL_START) //No need to send SUPL_END to SLP + { + iSuplSessionState = ESUPL_SESSION_ERROR; + break; + } + } + case ESUPL_SEND: + { + iErrorStatusCode = COMASuplEnd::EUnspecified; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + if(iOMASuplPOSRequestor) //Reset observer + { + iOMASuplPOSRequestor->SetObserver(NULL); + } + TRAP_IGNORE(GenerateSuplMessageL()); + //iSuplSessionState = ESUPL_SESSION_ERROR; Cancel Bug + break; + } + default: break; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CancelRunSession +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::CancelRunSession() + { + CancelSession(); + if(iSuplSessionState == ESUPL_SEND) + { + CompleteSession(KErrCancel); + } + else + { + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrCancel); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleGenerationErrorL +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleGenerationErrorL(TInt aErr) + { + TBool cancelSendRequestor = ETrue; + if(iSuplState) + { + switch(iSuplState->GetSuplState()) + { + case COMASuplState::ESUPL_START: + { + break; + } + case COMASuplState::ESUPL_POS: + case COMASuplState::ESUPL_POS_INIT: + { + iErrorStatusCode = COMASuplEnd::EUnspecified; + if(aErr == KErrSuplposMethodMismatch) + iErrorStatusCode = COMASuplEnd::EPosProtocolMismatch;//COMASuplEnd::EPosMethodMismatch; + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + break; + } + case COMASuplState::ESUPL_END: + { + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, aErr); + cancelSendRequestor = EFalse; + break; + } + default: break; + } + } + + if(cancelSendRequestor) + { + CancelAllOperations(); + CleanUp(); + CompleteSession(aErr); + } + + } +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleInitilizationErrorL +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleInitilizationErrorL(TInt aErr) + { + CancelAllOperations(); + CleanUp(); + CompleteSession(aErr); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleConnectionErrorL +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleConnectionErrorL(TInt aErr) + { + CancelAllOperations(); + //Close Connection + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, aErr); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleEncodingErrorL +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleEncodingErrorL(TInt aErr) + { + TBool cancelSendRequestor = ETrue; + if(iSuplState) + { + iErrorStatusCode = COMASuplEnd::EUnspecified; + + if(aErr == KErrOMASETCapMisMatch ) + { + iErrorStatusCode = COMASuplEnd::EPosMethodMismatch; + iFailedCaps = iAllowedCapabilities; + iCapsFail = ETrue; + } + + if(aErr == KErrSuplposMethodMismatch) + { + iErrorStatusCode = COMASuplEnd::EPosProtocolMismatch; + } + if(aErr == KErrOMAManParamMissing) + { + iErrorStatusCode = COMASuplEnd::EDataMissing; + } + + if(aErr == KErrArgument) + { + iErrorStatusCode = COMASuplEnd::EUnexpectedDataValue; + } + + if(aErr == KErrOMASuplPosInfo || aErr == KErrOMASuplPosInActive || aErr == KErrOMASuplDataMissing) + { + iErrorStatusCode = COMASuplEnd::EDataMissing; + } + + switch(iSuplState->GetSuplState()) + { + case COMASuplState::ESUPL_START:break; + case COMASuplState::ESUPL_POS: + { + //This is for,even though we gets error(no pos payload data) for first POS message from plugin + // Just ignore it ... Don't put new pending request for POS message plugin. + if(iIsFirstPOSMessage && ( aErr == KErrOMAManParamMissing || aErr == KErrOMASuplParamNotSet || aErr == KErrOMASuplPosInfo)) + { + iTrace->Trace(_L("Failed to Generate First messsage from POS...still continueing.."), KTraceFileName, __LINE__); + iIsFirstPOSMessage = EFalse; + return; + } + } + case COMASuplState::ESUPL_POS_INIT: + { + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + break; + } + + case COMASuplState::ESUPL_END: + { + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + + default: break; + } + } + + if(cancelSendRequestor) + { + CancelAllOperations(); + CleanUp(); + CompleteSession(KErrGeneral); + } + + } +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleSendErrorL +// Cancels an in-progress RunSession on the Session +// What action to be taken for cancelRunSession will be depend on State of session. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleSendErrorL(TInt aErr) + { + // if error code is KErrDisconnected, then close connection + // and set the state accordingly + if (aErr == KErrDisconnected) + { + //Close Connection + iConnRequestor->CloseConnection(); + iSessionObserver.TerminateSession(this, aErr); + iDisconnected = ETrue; + } + else + { + TBool cancelSendRequestor = ETrue; + if(aErr == KErrTimedOut) + { + iErrorStatusCode = COMASuplEnd::EUnspecified; + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + + if(aErr == KErrSuplposMethodMismatch) + { + iErrorStatusCode = COMASuplEnd::EPosProtocolMismatch; + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + + aErr = KErrCompletion; + + if(cancelSendRequestor) + { + CancelAllOperations(); + CleanUp(); + CompleteSession(aErr); + } + } + + } +// ----------------------------------------------------------------------------- +// COMASuplSession::HandlePacketsErrorL +// HandlePacketsErrorL +// +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandlePacketsErrorL(TInt aErr) + { + TBool cancelSendRequestor = ETrue; + + if(iSuplMsgType == ESUPL_INIT) + { + HandleSuplInitErrorL(aErr); + return; + } + + if(aErr == KErrSuplEndProtocolError ) + { + aErr = KErrCompletion; + switch(iSuplMsgType) + { + case ESUPL_START: + case ESUPL_RESPONSE: + case ESUPL_END: + { + //Close Connection + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, aErr); + break; + } + case ESUPL_REPORT: + { + //Close Connection + iConnRequestor->CloseConnection(); + break; + } + default: break; + } + } + + if(aErr == KErrOMASuplProtocolError ) + { + aErr = KErrCompletion; + switch(iSuplMsgType) + { + case ESUPL_START: + case ESUPL_INIT: + case ESUPL_POS: + case ESUPL_RESPONSE: + case ESUPL_POSINIT: + case ESUPL_TRIG_START: + case ESUPL_AUTH_RESP: + { + iErrorStatusCode = COMASuplEnd::EUnexpectedMessage; + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + break; + } + + case ESUPL_END: + { + //Close Connection + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, aErr); + break; + } + + default: break; + } + } + + if( aErr == KErrOMANonProxyModeNotSupported) //aErr == KErrOMASuplVersionNotMatching || + { + iErrorStatusCode = COMASuplEnd::ENonProxyModeNotSupported; + + aErr = KErrCompletion; + + if(iSuplState) + { + switch(iSuplState->GetSuplState()) + { + case COMASuplState::ESUPL_RESPONSE: + { + cancelSendRequestor = EFalse; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + break; + } + default: break; + } + } + } + + if(cancelSendRequestor) + { + CancelAllOperations(); + CleanUp(); + CompleteSession(aErr); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleSuplInitErrorL +// Handle Init related error +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleSuplInitErrorL(TInt aErr) + { + iTrace->Trace(_L("Start COMASuplSession::HandleSuplInitError"), KTraceFileName, __LINE__); + + if(aErr == KErrOMAInvalidHSLPAddress) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError HSLP Address is not matching..."), KTraceFileName, __LINE__); + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrCompletion); + return; + } + + TBool setStatusCode = ETrue; + + + if(aErr == KErrSuplInvalidSessionID) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError Received SET Session ID"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EInvalidSessionId; + + COMASuplSessionID* retrivedSessionID = NULL; + iDecodedAsnMessage->SessionId(retrivedSessionID); + + // Set the SessionId. + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError Update SET Session ID"), KTraceFileName, __LINE__); + UpdateSETSessionIDL(retrivedSessionID); + + } + + if(aErr == KErrOMANonProxyModeNotSupported) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError Received Nonproxymode data"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::ENonProxyModeNotSupported; + } + + if(KErrAccessDenied == aErr || KErrOMASuplDenied == aErr) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError KErrAccessDenied|| KErrOMASuplDenied"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EConsentDeniedByUser; + } + + if(aErr == KErrOMASuplNoPosition || KErrOMASuplInformationOnly == aErr) + { + //Supl End with No Position + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError KErrOMASuplNoPosition || KErrOMASuplInformationOnly"), KTraceFileName, __LINE__); + setStatusCode = EFalse; + } + + if(KErrOMASuplAccepted == aErr) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError EConsentGrantedByUser"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EConsentGrantedByUser; + } + + if (KErrSuplServiceNotSupported == aErr) + { + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError E"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EVer2ServiceNotSupported; + } + TInt len = iHSLPAddress.Length(); + HBufC8 *hslpAdress = NULL; + if(len > 0) + { + hslpAdress = HBufC8::NewL(iHSLPAddress.Length()); + hslpAdress->Des().Copy(iHSLPAddress); + } + + else if(len ==0) + { + iTrace->Trace(_L("HSLP generated frm IMSI"), KTraceFileName, __LINE__); + hslpAdress = HBufC8::NewL(iSuplSettings->SLPAddressfromImsi().Length()); + CleanupStack::PushL(hslpAdress); + hslpAdress->Des().Copy(iSuplSettings->SLPAddressfromImsi()); + CleanupStack::Pop(hslpAdress); + + } + CleanupStack::PushL(hslpAdress); + + delete iSuplState; + iSuplState = NULL; + + if(setStatusCode) + { + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl,iEncodedSuplInit,hslpAdress); + } + else + { + iSuplState = COMASuplEndState::NewL(iOMASuplAsnHandlerBaseImpl,iEncodedSuplInit,hslpAdress ); + } + + CleanupStack::PopAndDestroy(hslpAdress); + + iTrace->Trace(_L("COMASuplSession::HandleSuplInitError Send SUPL_END for SUPL_INIT"), KTraceFileName, __LINE__); + + + iSuplSessionState = ESUPL_INITIALIZED; + iSuplState->SetMsgStateObserver(this); + iSuplMsgType = ESUPL_END; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + iSuplState->GenerateMessageL(); + iSuplSessionState = ESUPL_GENERATE; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleInvalidParameterErrorL +// Handles error occured related invalid parameter. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::HandleInvalidParameterErrorL(COMASuplAsnMessageBase* aDecodedAsnMessage) + { + iTrace->Trace(_L("COMASuplSession::HandleInvalidParameterErrorL"), KTraceFileName, __LINE__); + if(CheckProtocolVersionL(aDecodedAsnMessage)) //Checks version with supported version + { + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedAsnMessage->MessageType(); + CancelAllOperations(); + if(messageType == COMASuplAsnMessageBase::ESUPL_END) + { + //Close Connection : bug Fix. + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrCompletion); + } + else + { + + iErrorStatusCode = COMASuplEnd::EUnexpectedDataValue; + + if((messageType == COMASuplAsnMessageBase::ESUPL_POSINIT || + messageType == COMASuplAsnMessageBase::ESUPL_START || + messageType == COMASuplAsnMessageBase::ESUPL_RESPONSE) + && (iRequestType == ESUPL_NETWORK)) + { + iErrorStatusCode = COMASuplEnd::EUnexpectedMessage; + } + + if(iRequestType == ESUPL_TERMINAL ) //Protocol errors + { + if( ! (iSuplMsgType == ESUPL_START && messageType == COMASuplAsnMessageBase::ESUPL_RESPONSE) + || + (iSuplMsgType == ESUPL_POSINIT && messageType == COMASuplAsnMessageBase::ESUPL_POS) + ) + + { + iErrorStatusCode = COMASuplEnd::EUnexpectedMessage; + } + } + + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::TerminateSession +// Terminates session +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::TerminateSession() + { + iTrace->Trace(_L("COMASuplSession::TerminateSession"), KTraceFileName, __LINE__); + if(iSuplSessionState != ESUPL_SESSION_ERROR) + { + CancelRunSession(); + } + else + { + SessionEnd(); + CompleteSession(KErrCancel); + } + return; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SuplVersion +// returns SUPL Version +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TReal COMASuplSession::SuplVersion() + { + return KSuplPOSPluginVersion; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetPOSMsgPluginState +// Informs Protocol state to POS if present +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void COMASuplSession::SetPOSMsgPluginState(COMASuplPosSessionBase::TOMASuplMsgState aSuplMsgState) + { + if(iPOSSession != NULL) + { + iTrace->Trace(_L("Setting State of POS Msg Plugin"), KTraceFileName, __LINE__); + + COMASuplPosSessionBase::TOMASuplMsg SuplMsg = COMASuplPosSessionBase::EOMASuplStart; + + switch(iSuplMsgType) + { + case ESUPL_START: + SuplMsg = COMASuplPosSessionBase::EOMASuplStart; + break; + case ESUPL_RESPONSE: + SuplMsg = COMASuplPosSessionBase::EOMASuplResponse; + break; + case ESUPL_INIT: + SuplMsg = COMASuplPosSessionBase::EOMASuplInit; + break; + case ESUPL_POSINIT: + SuplMsg = COMASuplPosSessionBase::EOMASuplPosInit; + break; + case ESUPL_POS: + SuplMsg = COMASuplPosSessionBase::EOMASuplPos; + break; + case ESUPL_END: + SuplMsg = COMASuplPosSessionBase::EOMASuplEnd; + break; + default: + break; + } + + iPOSSession->SetSuplState(SuplMsg,aSuplMsgState); + } + + } +// ----------------------------------------------------------------------------- +// COMASuplSession::IsLastPOSMessage +// Checks about last POS message with POS handler +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool COMASuplSession::IsLastPOSMessage() + { + if( iPOSSession && iSuplState) + { + COMASuplPosState* state = static_cast (iSuplState); + TBool ret = state->IsLastMessage(); + return ret; + } + else + { + return EFalse; + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::IsSegmentedDone() +// Checks about segmentation of pospayload +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool COMASuplSession::IsSegmentationDone() + { + if( iPOSSession && iSuplState) + { + COMASuplPosState* state = static_cast (iSuplState); + TBool ret = state->IsSegmentationDone(); + return ret; + } + else + { + return EFalse; + } + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::CopySETCapabilities +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void COMASuplSession::CopySETCapabilities() + { + if(iSuplMsgType == ESUPL_START) + { + COMASuplStartState *startState = static_cast (iSuplState); + COMASuplSETCapabilities *setCaps = startState->Capabilities(); + + TOMASuplPosTechnology posTech; + COMASuplSETCapabilities::TOMASuplPrefMethod prefMethod; + TOMASuplPosProtocol posProtocol; + + setCaps->GetSETCapabilities(posTech,prefMethod,posProtocol); + + iSETCapabilities->SetSETCapabilities(posTech,prefMethod, posProtocol); + } + + if (iTriggerSession && iSuplMsgType == ESUPL_TRIG_START) + { + COMASuplTriggerStartState *trgStartState = static_cast (iSuplState); + COMASuplSETCapabilities *setCaps = trgStartState->Capabilities(); + + TOMASuplPosTechnology posTech; + COMASuplSETCapabilities::TOMASuplPrefMethod prefMethod; + TOMASuplPosProtocol posProtocol; + + setCaps->GetSETCapabilities(posTech,prefMethod,posProtocol); + + iSETCapabilities->SetSETCapabilities(posTech,prefMethod, posProtocol); + } + + if(iSuplMsgType == ESUPL_POSINIT && iRequestType == ESUPL_NETWORK && !iTriggerSession) + { + TOMASuplPosTechnology posTechnology; + COMASuplSETCapabilities::TOMASuplPrefMethod prefMethod; + TOMASuplPosProtocol posProtocol; + + TBool GpsSETAssisted = EFalse; + TBool GpsSETBased = EFalse; + TBool AutonomousGps = EFalse; + TBool FLT = EFalse; + TBool eOTD = EFalse; + TBool oTDOA = EFalse; + + TBool TIA801 = EFalse; + TBool RRLP = EFalse; + TBool RRC = EFalse; + + posTechnology.SetPosTechnology(GpsSETAssisted,GpsSETBased,AutonomousGps,FLT, + eOTD,oTDOA); + posProtocol.SetPosProtocol(TIA801,RRLP,RRC); + prefMethod = COMASuplSETCapabilities::EOMANoPreferred; + iSETCapabilities->SetSETCapabilities(posTechnology,prefMethod,posProtocol); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::PrivacyCheckCompleteL +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void COMASuplSession::PrivacyCheckCompleteL(TInt aCompletionCode) + { + if(aCompletionCode == KErrNone) + { + iTrace->Trace(_L("COMASuplSession::PrivacyCheckCompleteL No Error"), KTraceFileName, __LINE__); + static_cast(iSuplState)->GetRequestorIDAndName(iRequestID,iRequestorName); + static_cast(iSuplState)->GetPrivacyStatus(iPrivacyOverride); + static_cast(iSuplState)->GetSuplPrivacyRequestInfo(iSuplReqInfo); + + iSuplSessionState = ESUPL_INITIALIZED; + iSuplMsgType = ESUPL_POSINIT; + if (iSuplUsage >= 2) + { + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + COMASuplNotification* notif; + TInt error = suplInit->Notification(notif); + COMASuplNotification::TOMASuplNotificationType notifType = notif->SuplNotification(); + if (notifType == COMASuplNotification::ENotificationOnly) + { + InitializeL(iRequestID); //APE Centric + } + else + { + //iRequestID = 0; //APE Centric + CheckForSuplUsageL(); + } + } + else + InitializeL(iRequestID); + } + else + { + iTrace->Trace(_L("COMASuplSession::PrivacyCheckCompleteL with Error "), KTraceFileName, __LINE__); + if (iSuplUsage >= 2) + { + iNwInitError = ETrue; + iNwInitCompletionCode = aCompletionCode; + CheckForSuplUsageL(); + } + else + HandleSuplInitErrorL(aCompletionCode); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetConfigurationParameters...sets configuration parameters +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void COMASuplSession::SetConfigurationParameters(TInt& aUT1_StartTimer,TInt& aUT2_PosInitTimer, + TInt& aUT3_PosTimer,TInt& aPrivacyTimer, + TInt& aSETMode, + TInt& aSuplUsage, + TInt& aPersistFailTimer, + TInt& aSuplInitTimeOut) + { + iUT1_StartTimer = aUT1_StartTimer; + iUT2_PosInitTimer = aUT2_PosInitTimer; + iUT3_PosTimer = aUT3_PosTimer; + iPrivacyTimer = aPrivacyTimer; + iSETMode = aSETMode; + iSuplUsage = aSuplUsage; + iPersistFailTimer = aPersistFailTimer; + iSuplInitTimeOut = aSuplInitTimeOut; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::IsGenerationInProgress...check about status of generation of message +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +TBool COMASuplSession::IsGenerationInProgress() + { + if( iSuplMsgType == ESUPL_POSINIT && iSuplState) + { + COMASuplPosInitState* state = static_cast (iSuplState); + TBool ret = state->IsGenerationInProgress(); + return ret; + } + else + { + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::LogEndTime...log the end time if delay is present in QoP +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +void COMASuplSession::LogEndTime() + { + if(!iIsQoPPresent) + { + return; + } + + TInt delay; + if(iClientQop.GetDelay(delay) != KErrNotFound) + { + iSessionEndTime.HomeTime(); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetIMSIL +// Updates IMSI value in SET Session ID +// ----------------------------------------------------------------------------- +void COMASuplSession::SetIMSI() + { + + { + iTrace->Trace(_L("COMASuplSession::SetIMSIL Start"), KTraceFileName, __LINE__); + TInt length = iIMSI.Length(); + TBuf8 imsi; + TUint8 val; + TInt index = 0; + + while ( index <= length ) + { + val = 0; + if (index == length) + { + val = 15 << 4; + val |= 15; + imsi.Append(val); + break; + } + const TUint16& t = iIMSI[index]; + TInt8 i = t - 48; + if ( ++index != length ) + { + const TUint16& h = iIMSI[index]; + TInt8 j = h - 48; + val = j << 4; + val |= i; + } + else + { + val = 15 << 4; + val |= i; + } + + imsi.Append(val); + index++; + } + + if (!iSessionIDFlag) + { + COMASuplSETSessionID* suplSETSessionId = NULL; + iSuplSessionId->SETSessionID( suplSETSessionId ); + suplSETSessionId->SetSuplSETSessionIDIMSI( iSETSessionUniqueId, imsi ); + } + + iTrace->Trace(_L("COMASuplSession::SetIMSI End"), KTraceFileName, __LINE__); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::IsIMSIVariant +// Checks to determine if IMSI needs to be included in the SUPL message +// ----------------------------------------------------------------------------- +TBool COMASuplSession::IsIMSIVariant() + { + if(iIMSI.Length() && + ( + (iRequestType == ESUPL_TERMINAL && iSuplMsgType == ESUPL_START) || + (iRequestType == ESUPL_TERMINAL && iSuplMsgType == ESUPL_TRIG_START) || + (iRequestType == ESUPL_NETWORK && iSuplMsgType == ESUPL_TRIG_START && iTriggerSession) || + (iRequestType == ESUPL_TERMINAL && iSuplMsgType == ESUPL_POSINIT && iTriggerSession) || + (iRequestType == ESUPL_NETWORK && iSuplMsgType == ESUPL_POSINIT) || + (iRequestType == ESUPL_NETWORK && iSuplMsgType == ESUPL_END) + )) + { + return ETrue; + } + else + { + return EFalse; + } + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::SettingsUICompleted +// +// ----------------------------------------------------------------------------- + +void COMASuplSession::SettingsUICompletedL(TInt /*aError*/) + { + iTrace->Trace(_L("COMASuplSession::SettingsUICompleted ..."), KTraceFileName, __LINE__); + + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleInvalidMessageL +// Sends SUPL_END with status code with wrong message +// ----------------------------------------------------------------------------- +void COMASuplSession::HandleInvalidMessageL(COMASuplAsnMessageBase* aDecodedAsnMessage) + { + + if(CheckProtocolVersionL(aDecodedAsnMessage)) //Checks version with supported version + { + iTrace->Trace(_L("COMASuplSession::HandleInvalidMessageL...Sending SUPL_END for invalid message"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EUnexpectedMessage; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleInvalidMessageLengthL +// Sends SUPL_END with status code with protocol error +// ----------------------------------------------------------------------------- +void COMASuplSession::HandleInvalidMessageLengthL() + { + iTrace->Trace(_L("COMASuplSession::HandleInvalidMessageLengthL...Sending SUPL_END for invalid message length"), KTraceFileName, __LINE__); + iErrorStatusCode = COMASuplEnd::EProtocolError; + iSuplSessionState = ESUPL_GENERATE; + iSuplMsgType = ESUPL_END; + GenerateSuplMessageL(); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CheckProtocolVersion +// Returns true if its matching else false +// ----------------------------------------------------------------------------- +TBool COMASuplSession::CheckProtocolVersionL(COMASuplAsnMessageBase* aDecodedAsn) + { + TOMASuplVersion version; + COMASuplSessionID* SessionID = NULL; + aDecodedAsn->MessageBase(version,SessionID); + + TInt recMajor,recMinor,recServInd; + version.SuplVersion(recMajor,recMinor,recServInd); + + if(recMajor == KSuplMajorVersion ) + { + return ETrue; + } + else + { + COMASuplAsnMessageBase::TSuplMessageType messageType = aDecodedAsn->MessageType(); + if(messageType == COMASuplAsnMessageBase::ESUPL_END) + { + iTrace->Trace(_L("Received message is SUPL_END...with wrong Version.Terminating session"), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrCompletion); + } + else + { + iTrace->Trace(_L("Received message with wrong version."), KTraceFileName, __LINE__); + + delete iSuplState; + iSuplState = NULL; + iSuplMsgType = ESUPL_END; + iErrorStatusCode = COMASuplEnd::EVersionNotSupported; + SetPOSMsgPluginState(COMASuplPosSessionBase::EOMASuplCreating); + + if(iRequestType == ESUPL_NETWORK ) + { + if (messageType == COMASuplAsnMessageBase::ESUPL_INIT) + { + iSuplSessionState = ESUPL_INITIALIZED; + TInt len = iHSLPAddress.Length(); + HBufC8 *hslpAdress = NULL; + if(len > 0) + { + hslpAdress = HBufC8::NewL(iHSLPAddress.Length()); + hslpAdress->Des().Copy(iHSLPAddress); + } + else if(len ==0) + { + iTrace->Trace(_L("Length of HSLP Address is = 0, passing the HSLP generated frm IMSI"), KTraceFileName, __LINE__); + hslpAdress = HBufC8::NewL(iSuplSettings->SLPAddressfromImsi().Length()); + CleanupStack::PushL(hslpAdress); + hslpAdress->Des().Copy(iSuplSettings->SLPAddressfromImsi()); + CleanupStack::Pop(hslpAdress); + } + + CleanupStack::PushL(hslpAdress); + ServerAddressCheckForSuplInitL(); + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl,iEncodedSuplInit,hslpAdress); + CleanupStack::PopAndDestroy(hslpAdress); + + // Set the SessionId. + iTrace->Trace(_L("COMASuplSession::CheckProtocolVersionL Update SLP Session ID"), KTraceFileName, __LINE__); + UpdateSLPSessionIDL(SessionID); + + iTrace->Trace(_L("COMASuplSession::CheckProtocolVersionL Update SET Session ID"), KTraceFileName, __LINE__); + UpdateSETSessionIDL(SessionID); + iSuplState->SetMsgStateObserver(this); + iSuplState->GenerateMessageL(); + iSuplSessionState = ESUPL_GENERATE; + } + else + { + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl); + UpdateSLPSessionIDL(SessionID); + UpdateSETSessionIDL(SessionID); + iSuplState->SetMsgStateObserver(this); + iRequestType = ESUPL_INVALID_SESSION; + iSuplSessionState = ESUPL_GENERATE; + iSuplState->GenerateMessageL(); + } + + } + else + { + iSuplState = COMASuplEndState::NewL(iErrorStatusCode,iOMASuplAsnHandlerBaseImpl); + iSuplSessionState = ESUPL_ENCODE; + iSuplState->SetMsgStateObserver(this); + UpdateSLPSessionIDL(SessionID); + UpdateSETSessionIDL(SessionID); + iSuplState->GenerateMessageL(); + } + } + + return EFalse; + } + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetRemainingPosPayloadL +// Returns remaining pos payload +// ----------------------------------------------------------------------------- +COMASuplPosPayload* COMASuplSession::GetRemainingPosPayloadL() + { + if( iSuplState && COMASuplState::ESUPL_POS_INIT == iSuplState->GetSuplState()) + { + COMASuplPosInitState* state = static_cast (iSuplState); + return state->GetRemainingPospayLoadL(); + } + else + { + return NULL; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::IsWholeMessageSent +// Is whole message get sent +// ----------------------------------------------------------------------------- +TBool COMASuplSession::IsWholeMessageSentL() + { + COMASuplState::TSuplMessageType msgType = iSuplState->GetSuplState(); + switch(msgType) + { + case COMASuplState::ESUPL_POS_INIT: + { + COMASuplPosPayload* remainingPosPayload = GetRemainingPosPayloadL(); + if(remainingPosPayload ) + return EFalse; + else + return ETrue; + } + + case COMASuplState::ESUPL_POS: + { + return !IsSegmentationDone(); + } + default : //For Start , End + { + return ETrue; + } + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetNetworkModeL() +// Checks wheather phone is online or Offline mode... +// ----------------------------------------------------------------------------- + +TInt COMASuplSession::GetNetworkModeL() + { + + TInt networkMode; + // get network mode + CRepository* centralRepository = CRepository::NewLC(KCRUidCoreApplicationUIs); + User::LeaveIfError(centralRepository->Get(KCoreAppUIsNetworkConnectionAllowed, networkMode)); + CleanupStack::PopAndDestroy(centralRepository); + return networkMode; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetSessionUIFlag +// Sets/Resets the Session UI flag +// ----------------------------------------------------------------------------- +void COMASuplSession::SetSessionUIFlag(TBool aValue) + { + iUIFlag = aValue; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::GetSessionUIFlag +// Returns Session UI flag +// ----------------------------------------------------------------------------- +TBool COMASuplSession::GetSessionUIFlag() + { + return iUIFlag; + } + + + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// COMASuplSession::CloseAllOperations +// Close all operations...from here we will stop all processing releated with session and will +// not send SUPL_END +// ----------------------------------------------------------------------------- +void COMASuplSession::CloseAllOperations() + { + iCompleteSelfRequestor->CompleteInvalidSLPSession(); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::HandleInvalidSLPSessionL +// Relinquish control to Communication manager.... +// +// ----------------------------------------------------------------------------- +void COMASuplSession::HandleInvalidSLPSession() + { + iTrace->Trace(_L("Cancelling All operations..since received invalid SLP session..."), KTraceFileName, __LINE__); + iConnRequestor->CancelReadOperation(); + CancelAllOperations(); + iConnRequestor->CloseConnection(); + iPortNum = 0; + iSessionObserver.TerminateSession(this, KErrCompletion);//// Invoke Terminate Session + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::IsUIDisplayedL +// Checks whether UI is displayed or not previously +// +// ----------------------------------------------------------------------------- + +TBool COMASuplSession::IsUIDisplayedL() + { + /* + TBool retValue = EFalse; + RBuf HSLPIPAddress; + RBuf IAP_Name; + RBuf Imsi; + CSuplSettings::TSuplSettingsChangedBy changedBy; + + HSLPIPAddress.CreateL(KMaxIPAddressLength); + CleanupClosePushL(HSLPIPAddress); + + IAP_Name.CreateL(KMaxIapNameLength); + CleanupClosePushL(IAP_Name); + + Imsi.CreateL(KMaxImsiLength); + CleanupClosePushL(Imsi); + + TInt error = iSuplStorageSettings->Get(HSLPIPAddress, IAP_Name, Imsi, changedBy); + + if(!error && (IAP_Name.Length() != 0)) + { + if (IAP_Name.Compare(_L("-")) == 0) + retValue = ETrue; + } + CleanupStack::PopAndDestroy(3); + return retValue; + */ + return EFalse; + } + + +// ----------------------------------------------------------------------------- +// COMASuplSession::SetSETSessionIdL +// Sets the proper SET Session id depending on the type of Varient. +// +// ----------------------------------------------------------------------------- + +TInt COMASuplSession::SetApproriateSETSessionId() + { + TInt err = KErrNone; + if( IsIMSIVariant() ) + { + SetIMSI(); + } + else + { + err = GetLocalIPAddress(); + } + + return err; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::TimerExpiredL +// Checks whether UI is displayed or not previously +// +// ----------------------------------------------------------------------------- +void COMASuplSession::TimerExpiredL() + { + iTrace->Trace(_L("Timer Expired for SUPL_POSINIT"), KTraceFileName, __LINE__); + OperationCompleteL(KErrTimedOut); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SettingsUsageUICompletedL +// +// ----------------------------------------------------------------------------- +void COMASuplSession::SettingsUsageUICompletedL(TInt aError) + { + iUIFlag = EFalse; + TBuf<64> msg; + msg.Copy(_L("SUPL Usage UI completed with ... ")); + msg.AppendNum(aError); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + iPrevUsageResult = aError; + + + + if (aError == KErrNone) + { + iProtocolManager.UpdateAllSubSessnsInSameSession(iIpcSessionId); + + if (isTimeoutDialogTimerStarted) + { + iTrace->Trace(_L("COMASuplSession::SettingsUsageUICompletedL, stopping timer "), KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = EFalse; + iDialogTimer->StopTimer(); + + //Compute how log the dialog was on + TTime nowTime; + nowTime.HomeTime(); + nowTime.SecondsFrom(iDlgStartTime, iDiffTime); + } + if (iNwInitError) + { + iNwInitError = EFalse; + HandleSuplInitErrorL(iNwInitCompletionCode); + } + else + InitializeL(iRequestID); + } + else if (aError == KErrCompletion) + CheckForSuplUsageL(); + else + { + TBuf<64> msg; + msg.Copy(_L("Error after SUPL Usage Popup... ")); + msg.AppendNum(aError); + iTrace->Trace(msg,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CheckForSuplUsageL +// +// ----------------------------------------------------------------------------- +void COMASuplSession::CheckForSuplUsageL() + { + iTrace->Trace(_L("COMASuplSession::CheckForSuplUsageL Start"), KTraceFileName, __LINE__); + + if (iSuplUsage >= 1) + { + CSuplSettings::TSuplSettingsUsage usage = iSuplSettings->SUPLUsage(); + if (usage == CSuplSettings::ESuplUsageDisabled) + { + iTrace->Trace(_L("CheckForSuplUsageL, SUPL disabled"), KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + } + else if (usage == CSuplSettings::ESuplUsageAutomatic) + { + if (iNwInitError) + { + iNwInitError = EFalse; + HandleSuplInitErrorL(iNwInitCompletionCode); + } + else + { + iTrace->Trace(_L("CheckForSuplUsageL, Initializing"), KTraceFileName, __LINE__); + InitializeL(iRequestID); + } + } + + else if (usage == CSuplSettings::ESuplUsageHomeAutomatic || usage == CSuplSettings::ESuplUsageAlwaysAsk) + { + if (iRoaming) + HandleRoamingCheckCompleteL(KErrNone, EFalse); + else + { + iEtelRoamingCheck = ETrue; + iProtocolManager.CheckForRoaming(); + } + } + } + else + InitializeL(iRequestID); + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::CheckForTimerExpiry +// +// ----------------------------------------------------------------------------- +void COMASuplSession::CheckForTimerExpiry() + { + if (iPersistFail) + { + TTime nowTime; + nowTime.HomeTime(); + TTimeIntervalMicroSeconds diff = nowTime.MicroSecondsFrom(iFailTime); + + if (diff > (iPersistFailTimer * KSecond) ) + iChanged = ETrue; + } + } +// ----------------------------------------------------------------------------- +// COMASuplSession::CheckForPreviousResultL +// +// ----------------------------------------------------------------------------- +void COMASuplSession::CheckForPreviousResultL() + { + CheckForTimerExpiry(); + if (iChanged) + { + iProtocolManager.CancelNotify(); + iEtelNotify = EFalse; + iPersistFail = EFalse; + iCapsFail = EFalse; + iChanged = EFalse; + CheckForSuplUsageL(); + return; + } + + // Check for previous request result + if (iPrevUsageResult == KErrNone && !iPersistFail && !iCapsFail) + { + InitializeL(iRequestID); + } + else if (iCapsFail && iAllowedCapabilities != iFailedCaps) + { + InitializeL(iRequestID); + } + else + { + + if (iPrevUsageResult != KErrNone) + iSessionObserver.TerminateSession(this, iPrevUsageResult); + else if (iPersistFail) + iSessionObserver.TerminateSession(this, iPrevReqResult); + else if (iCapsFail) + iSessionObserver.TerminateSession(this, KErrGeneral); + } + } + +void COMASuplSession::HandleCurrentNetworkChangeL(TInt aErrorCode, TBool aHomeNw) + { + iTrace->Trace(_L("COMASuplSession::HandleCurrentNetworkChangeL"), KTraceFileName, __LINE__); + iEtelNotify = EFalse; + if (aErrorCode == KErrNone) + { + iChanged = ETrue; + if (!aHomeNw) + { + iRoaming = ETrue; + } + else + iRoaming = EFalse; + } + } + +void COMASuplSession::HandleRoamingCheckCompleteL(TInt aErrorCode, TBool aHomeNw) + { + iTrace->Trace(_L("COMASuplSession::HandleRoamingCheckCompleteL"), KTraceFileName, __LINE__); + iEtelRoamingCheck = EFalse; + if (aErrorCode == KErrNone) + { + iUsageHomeNW = aHomeNw; + iConnRequestor->UpdateSLPListForHomeUsage(iUsageHomeNW); + CSuplSettings::TSuplSettingsUsage usage = iSuplSettings->SUPLUsage(); + + if (usage == CSuplSettings::ESuplUsageAlwaysAsk) + { + TInt err; + if (!aHomeNw) + { + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, ETrue); + } + else + { + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is not roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, EFalse); + } + + if(KErrNone != err && KErrInUse == err) + { + iTrace->Trace(_L("Dialog in use, setting flag"), KTraceFileName, __LINE__); + SetSuplUsageFlag(); + } + if( KErrNone == err && iRequestType == ESUPL_NETWORK ) + { + iTrace->Trace(_L("Network Session , starting timer"), KTraceFileName, __LINE__); + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + TInt delay; + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + TBuf<128> msg(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(delay); + } + else + { + if (iSuplInitTimeOut > 0) + { + TBuf<256> msg(_L("Delay value in CR is")); + msg.AppendNum(iSuplInitTimeOut); + iTrace->Trace(msg, KTraceFileName, __LINE__); + iDialogTimer->StartTimer(iSuplInitTimeOut * KSecond); + isTimeoutDialogTimerStarted = ETrue; + } + else + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + iDlgStartTime.HomeTime(); + } + else if (KErrNone != err) + { + iTrace->Trace(_L("Invoking HandleSuplErrorL"), KTraceFileName, __LINE__); + HandleSuplErrorL(err); + } + + } + else if (usage == CSuplSettings::ESuplUsageHomeAutomatic) + { + if (!aHomeNw) + { + TInt err; + //if (!iSuplSettings->IsUIActive() ) + { + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, ETrue); + + if(iSuplMsgType == ESUPL_INIT) + { + iTrace->Trace(_L("Dialog timer started"), KTraceFileName, __LINE__); + + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + TInt delay; + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + TBuf<128> msg(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(delay); + } + else + { + if (iSuplInitTimeOut > 0) + { + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(iSuplInitTimeOut * KSecond); + } + else + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + } + } + + + if(!iSuplSettings->IsUIActive() && KErrNone != err) + { + SetSuplUsageFlag(); + } + else + { + iTrace->Trace(_L("Invoking HandleSuplErrorL"), KTraceFileName, __LINE__); + HandleSuplErrorL(err); + } + } + else + { + if (iNwInitError) + { + iNwInitError = EFalse; + HandleSuplInitErrorL(iNwInitCompletionCode); + } + else + InitializeL(iRequestID); + } + } + } + else + { + iSessionObserver.TerminateSession(this, KErrGeneral); + } + } +TInt COMASuplSession::SuplIpcSessionID() + { + return iIpcSessionId; + } + +void COMASuplSession::UpdateSuplUsage() + { + iPrevUsageResult = KErrNone; + } + +void COMASuplSession::SettingsChanged() + { + iChanged = ETrue; + } + +void COMASuplSession::HandleIapSettingsChangeL(TInt aErrorCode) + { + iTrace->Trace(_L("COMASuplSession::HandleIapSettingsChangeL"), KTraceFileName, __LINE__); + if (aErrorCode >= 0) + iChanged = ETrue; + } + +void COMASuplSession::CheckForPersistentFailure(TInt aErrorCode) + { + if (iRequestType == ESUPL_TERMINAL) + { + if ( + (aErrorCode <= KErrDndNameNotFound && aErrorCode >= KErrDndServerUnusable) || // DNS errors + (aErrorCode <= KErrGprsAndNonGprsServicesNotAllowed && aErrorCode >= KErrGprsFeatureNotSupported) || // GPRS errors + (aErrorCode <= KErrSSLNoSharedCipher && aErrorCode >= KErrSSLDllLeave) || // TLS errors + (aErrorCode == KErrCouldNotConnect) // Server does not exist + ) + { + iPersistFail = ETrue; + iPrevReqResult = KErrGeneral; + + iFailTime.HomeTime(); + + iTrace->Trace(_L("COMASuplSession::CheckForPersistentFailure, listening to network change"), KTraceFileName, __LINE__); + iEtelNotify = ETrue; + iProtocolManager.NotifyCurrentNetworkChange(); + + iTrace->Trace(_L("COMASuplSession::CheckForPersistentFailure, listening to IAP change"), KTraceFileName, __LINE__); + if (!iIapNotifier->IsActive()) + iIapNotifier->NotifyIapSettingsChange(); + } + } + } +void COMASuplSession::SetSuplUsageFlag() + { + iUsageDialog = ETrue; + } + +void COMASuplSession::ReSetSuplUsageFlag() + { + iUsageDialog = EFalse; + } + +TBool COMASuplSession::GetSuplUsageFlag() + { + return iUsageDialog; + } + +void COMASuplSession::StartUsageDialogLaunchL() + { + iTrace->Trace(_L("COMASuplSession::StartUsageDialogLaunchL"), KTraceFileName, __LINE__); + ReSetSuplUsageFlag(); + iTrace->Trace(_L("COMASuplSession::StartUsageDialogLaunchL, flag reset done"), KTraceFileName, __LINE__); + + CSuplSettings::TSuplSettingsUsage usage = iSuplSettings->SUPLUsage(); + if (usage == CSuplSettings::ESuplUsageAlwaysAsk) + { + TInt err; + if (!iUsageHomeNW) + { + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, ETrue); + + if(iRequestType == ESUPL_NETWORK && err == KErrNone) + { + iTrace->Trace(_L("starting Dialog timer "), KTraceFileName, __LINE__); + + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + TInt delay; + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + TBuf<128> msg(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(delay); + } + else + { + if (iSuplInitTimeOut > 0) + { + iTrace->Trace(_L("Delay not present in message"), KTraceFileName, __LINE__); + TBuf<256> msg(_L("Delay value in CR is ")); + msg.AppendNum(iSuplInitTimeOut); + iDialogTimer->StartTimer(iSuplInitTimeOut * KSecond); + isTimeoutDialogTimerStarted = ETrue; + } + else + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + } + } + else + { + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is not roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, EFalse); + + if( iRequestType == ESUPL_NETWORK && err == KErrNone) + { + iTrace->Trace(_L("starting Dialog timer "), KTraceFileName, __LINE__); + + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + TInt delay; + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + TBuf<128> msg(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(delay); + } + else + { + if (iSuplInitTimeOut > 0) + { + iTrace->Trace(_L("Delay not present in message"), KTraceFileName, __LINE__); + TBuf<256> msg(_L("Delay value in CR is")); + msg.AppendNum(iSuplInitTimeOut); + iDialogTimer->StartTimer(iSuplInitTimeOut * KSecond); + isTimeoutDialogTimerStarted = ETrue; + } + else + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + } + } + + if(KErrNone != err) + { + iTrace->Trace(_L("Invoking HandleSuplErrorL"), KTraceFileName, __LINE__); + HandleSuplErrorL(err); + } + } + else if (usage == CSuplSettings::ESuplUsageHomeAutomatic) + { + if (!iUsageHomeNW) + { + TInt err; + iTrace->Trace(_L("Invoking LaunchSuplUsageSettingsUI, user is roaming"), KTraceFileName, __LINE__); + err = iProtocolManager.LaunchSuplUsageSettingsUI(this, ETrue); + + if(KErrNone != err) + { + iTrace->Trace(_L("Invoking HandleSuplErrorL"), KTraceFileName, __LINE__); + HandleSuplErrorL(err); + } + + if(iRequestType == ESUPL_NETWORK && err == KErrNone) + { + iTrace->Trace(_L("starting Dialog timer "), KTraceFileName, __LINE__); + + COMASuplInit* suplInit = static_cast (iDecodedAsnMessage); + TOMASuplQop qop; + TInt retVal = suplInit->Qop(qop); + TInt delay; + qop.Delay(delay); + //if delay is > 7, it is not valid + if (delay > 7) + delay = 0; + if(retVal == KErrNone && delay > 0) + { + TReal delayReal; + Math::Pow(delayReal, 2, (TReal)delay); + delay = (TInt) delayReal; + TBuf<128> msg(_L("Delay present in message, value is = ")); + msg.AppendNum(delay); + iTrace->Trace(msg, KTraceFileName, __LINE__); + isTimeoutDialogTimerStarted = ETrue; + iDialogTimer->StartTimer(delay); + } + else + { + if (iSuplInitTimeOut > 0) + { + iTrace->Trace(_L("Delay not present in message"), KTraceFileName, __LINE__); + TBuf<256> msg(_L("Delay value in CR is")); + msg.AppendNum(iSuplInitTimeOut); + iDialogTimer->StartTimer(iSuplInitTimeOut * KSecond); + isTimeoutDialogTimerStarted = ETrue; + } + else + iTrace->Trace(_L("Timeout is <= 0"), KTraceFileName, __LINE__); + } + } + } + else + { + if (iNwInitError) + { + iNwInitError = EFalse; + HandleSuplInitErrorL(iNwInitCompletionCode); + } + else + InitializeL(iRequestID); + } + } + } + +TBool COMASuplSession::IsEtelNotifySet() + { + iTrace->Trace(_L("COMASuplSession::IsEtelNotifySet"), KTraceFileName, __LINE__); + return iEtelNotify; + } + +TBool COMASuplSession::IsEtelRoamingSet() + { + iTrace->Trace(_L("COMASuplSession::IsEtelRoamingSet"), KTraceFileName, __LINE__); + return iEtelRoamingCheck; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::DialogTimerExpiredL +// Checks whether UI is displayed or not previously +// +// ----------------------------------------------------------------------------- +void COMASuplSession::DialogTimerExpiredL() + { + if (iTrgTimer) + { + iTrgTimer = EFalse; + if (iStartTimerFlag) + { + iStartTimerFlag = EFalse; + StartPeriodicTriggerTimer(); + } + else + { + iTrace->Trace(_L("Timer Expired for trigger session"), KTraceFileName, __LINE__); + StartTriggerPosSessionL(); + } + } + else + { + iTrace->Trace(_L("Timer Expired for SUPL Dialog"), KTraceFileName, __LINE__); + + + if (!iIapDialogShown) + iProtocolManager.LaunchSuplDialogTimeoutUI(this); + else + iIapDlgTimerExpired = ETrue; + + } + return; + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::SettingsTimeOutUICompletedL +// +// ----------------------------------------------------------------------------- +void COMASuplSession::SettingsTimeOutUICompletedL(TInt aError) + { + + TBuf<64> msg; + msg.Copy(_L("SUPL Timeout UI completed with ... ")); + msg.AppendNum(aError); + iTrace->Trace(msg,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::StoreCurrentCellIDL +// Stores current cell id in CR +// +// ----------------------------------------------------------------------------- +void COMASuplSession::StoreCurrentCellIDL(HPositionGenericInfo& /*aSuplPosInfo*/) + { + iTrace->Trace(_L("Calling StoreCurrentCellIDL"),KTraceFileName, __LINE__); + TPckg cellPkg(iCurrentCellId); + +#ifdef PRINT_MESSAGE + TBuf<64> msg; + msg.Copy(_L("cid=:")); + msg.AppendNum(iCurrentCellId.iCid); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("Lac=:")); + msg.AppendNum(iCurrentCellId.iLac); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("MCC=:")); + msg.AppendNum(iCurrentCellId.iMCC); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + msg.Copy(_L("MNC=:")); + msg.AppendNum(iCurrentCellId.iMNC); + iTrace->Trace(msg,KTraceFileName, __LINE__); +#endif + + CRepository* ConfigurationCenRepSession = CRepository::NewL(KCRUidOMASuplConfiguration); + CleanupStack::PushL(ConfigurationCenRepSession); + User::LeaveIfError(ConfigurationCenRepSession->Set(KOMASuplCurrentCellid, cellPkg)); + + CleanupStack::PopAndDestroy(ConfigurationCenRepSession); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::ServerAddressCheckForSuplInitL() +// Stores current cell id in CR +// +// ----------------------------------------------------------------------------- +TInt COMASuplSession::ServerAddressCheckForSuplInitL() + { + TBuf<256> serverName; + TBuf<64> msg; + + COMASuplSLPAddress* slpAddress = NULL; + COMASuplInit* SuplInit = static_cast (iDecodedAsnMessage); + TInt err = SuplInit->SLPAddress(slpAddress); + + if(err == KErrOMASuplParamNotSet) + { + msg.Copy(_L("SLP address is NOT PRESENT in SUPL_INIT.")); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + //Set default slp to Conn Requestor... + iConnRequestor->UseDefaultServerL(); + return KErrNone; + } + + COMASuplSLPAddress::TSuplSLPAddressType addressType = slpAddress->SLPAddressType(); + if(addressType == COMASuplSLPAddress::EFqdn) + { + HBufC8* fqdn; + TInt err = slpAddress->Fqdn(fqdn); + serverName.Copy(fqdn->Des()); + msg.Copy(_L("SLP address as FQDN is PRESENT in SUPL_INIT:")); + msg.Append(serverName); + iTrace->Trace(msg,KTraceFileName, __LINE__); + } + else + { + TBuf8<256> IPslpaddress; + slpAddress->IPvAddress(IPslpaddress); + serverName.Copy(IPslpaddress); + msg.Copy(_L("SLP address as IP is PRESENT in SUPL_INIT:")); + msg.Append(serverName); + iTrace->Trace(msg,KTraceFileName, __LINE__); + + } + + TBool isExist = iSuplStorageSettings->IsSlpExists(serverName); + if(isExist) + { + //Set to Conn Requestor... + iConnRequestor->UseServerL(serverName); + return KErrNone; + } + else + { + msg.Copy(_L("Dropping Packet.SLP absent in server List:")); + msg.Append(serverName); + iTrace->Trace(msg,KTraceFileName, __LINE__); + return KErrNotFound; + } + + } + +void COMASuplSession::RunTriggerSessionL( + TRequestStatus& aStatus, + TSuplTerminalPeriodicTrigger& aTriggerParams, + const TDesC& aHslpAddress, + TBool aFallBack, + TInt aAllowedCapabilities, + TInt aSessionIdSeed, + TInt aRequestID) + { + iRunRequestStatus = & aStatus; + *iRunRequestStatus = KRequestPending; + + iRequestID = aRequestID; + + iTrace->Trace(_L("Start COMASuplSession::RunTriggerSessionL"), KTraceFileName, __LINE__); + + // Log Session Id + TBuf<64> id; + id.Append(_L("Session Id is ")); + id.AppendNum(aSessionIdSeed); + iTrace->Trace(id,KTraceFileName, __LINE__); + + // Log Capability from client + id.Copy(_L("Received Capability is ")); + id.AppendNum(aAllowedCapabilities); + iTrace->Trace(id,KTraceFileName, __LINE__); + + iSETSessionUniqueId = aSessionIdSeed; + + TInt networkMode = 1; + networkMode = GetNetworkModeL(); + + if ( networkMode == ECoreAppUIsNetworkConnectionNotAllowed ) + { + id.Copy(_L("The device is in OFFLINE mode.")); + iTrace->Trace(id,KTraceFileName, __LINE__); + iSessionObserver.TerminateSession(this, KErrGeneral); + return; + } + else + { + id.Copy(_L("The device is in ON LINE mode.")); + iTrace->Trace(id,KTraceFileName, __LINE__); + } + + if(aAllowedCapabilities == 0) + { + iAllowedCapabilities = KGpsSETAssisted | KGpsSETBased | KAutonomousGps| KAFLT | KECID | KEOTD | KOTDOA | KCID; + } + else + { + iAllowedCapabilities = aAllowedCapabilities; + } + + //Ownership transfer to iSuplSessionId + iSuplSessionId->SetSLPSessionID(NULL); + + //Set flag to indicate that it is a triggering session + iTriggerSession = ETrue; + + //Store trigger parameters + iTriggerParams = aTriggerParams; + + iConnRequestor->SetDefaultParametersL(aHslpAddress,aFallBack); + + CheckForSuplUsageL(); + + // Clear Position.... + delete iPosition; + iPosition = NULL; + + iTrace->Trace(_L("End of COMASuplSession::RunTriggerSessionL"), KTraceFileName, __LINE__); + } + +void COMASuplSession::GetPeriodicTriggerParams() + { + iTrace->Trace(_L("COMASuplSession::GetPeriodicTriggerParams"), KTraceFileName, __LINE__); + iTriggerParams.Get(iNumFixes, iInterval, iStartTime); + iTotalNoOfFixes = iNumFixes; + iStartTimeCopy = iStartTime; + } + +void COMASuplSession::StartPeriodicTriggerTimer() + { + if (iNumFixes != 0) + { + iTrace->Trace(_L("COMASuplSession::StartPeriodicTriggerTimer"), KTraceFileName, __LINE__); + //Set flag to indicate timer for trigger + iTrgTimer = ETrue; + if (iStartTime != 0) + { + iDialogTimer->StartTimer(iStartTime * KSecond); + iStartTime = 0; + iStartTimerFlag = ETrue; + } + else + { + if(iTotalNoOfFixes == iNumFixes) + { + iDialogTimer->StartTimer(0); + } + else + { + iDialogTimer->StartTimer(iInterval * KSecond); + } + } + } + } + +void COMASuplSession::StartTriggerPosSessionL() + { + iTrace->Trace(_L("COMASuplSession::StartTriggerPosSessionL"), KTraceFileName, __LINE__); + + if (iClientNotify || iTotalNoOfFixes == iNumFixes) + { + //Check if fix already exists with the POS Plug-in + //in which case whole of POS session is not required. + + iClientNotify = EFalse; + if (iInterval > KMaxIntervalTime || iDisconnected || iStartTime > KMaxStartTime) + { + + iTrace->Trace(_L("Setting state to INITIALIZED"), KTraceFileName, __LINE__); + iStartTimeCopy = 0; + iSuplSessionState = ESUPL_INITIALIZED; + } + else + { + iTrace->Trace(_L("Setting state to CONNECTING"), KTraceFileName, __LINE__); + iSuplSessionState = ESUPL_CONNECTING; + } + + OperationCompleteL(KErrNone); + } + else + { + //Reset number of fixes to 0 so that if notify + //request comes after cancel has started, it will + //get completed with error + iNumFixes = 0; + CancelTriggerSession(); + } + } + +void COMASuplSession::NotifyTriggerFiredL(TRequestStatus& aStatus, TSuplTriggerFireInfo& aFireInfo) + { + iTrace->Trace(_L("COMASuplSession::NotifyTriggerFiredL"), KTraceFileName, __LINE__); + iRunRequestStatus = & aStatus; + *iRunRequestStatus = KRequestPending; + iTrgFireInfo = &aFireInfo; + iClientNotify = ETrue; + if (iNumFixes == 0) + { + CompleteSession(KErrGeneral); + } + + } + +void COMASuplSession::CancelTriggerSession() + { + // Check if trigger session is in progress. If not trigger session, silently discard. + if (!iTriggerSession) + return; + + // If the trigger session is over and SUPL END is already sent, + // then also silently discard + if (iSuplMsgType == ESUPL_END) + return; + + // If timer is running, stop timer and send SUPL TRIGGER STOP. + // Else check if POS session in progress and send SUPL TRIGGER STOP + if (iDialogTimer->IsTimerStarted()) + { + iDialogTimer->StopTimer(); + } + + iTrgCancelRequest = ETrue; + // Check if the triggering POS session in progress + if (iSuplMsgType == ESUPL_POSINIT || iSuplMsgType == ESUPL_POS || iInterval <= 10) + { + iSuplSessionState = ESUPL_CONNECTING; + } + else + { + // If POS session is not in progress, need to check for interval and progress + iSuplSessionState = ESUPL_INITIALIZED; + } + + TRAP_IGNORE(OperationCompleteL(KErrNone)); + + + } +// ----------------------------------------------------------------------------- +// COMASuplSession::InsertActiveSessionL +// +// +// ----------------------------------------------------------------------------- +void COMASuplSession::InsertActiveSessionL() + { + iTrace->Trace(_L("Inserting New Trigger Session into DB..."), KTraceFileName, __LINE__); + CTriggerParams::TRequestType requestType; + if(iRequestType == ESUPL_TERMINAL) + { + requestType = CTriggerParams::ETerminalInitiated; + } + else + { + requestType = CTriggerParams::ENetworkInitiated; + } + + CTriggerParams* activeSessionParam = CTriggerParams::NewLC(); + activeSessionParam->Set(iSETSessionUniqueId,iRequestorName,ETrue,ETrue,CTriggerParams::EPeriodic,requestType,iNumFixes,iInterval); + iTrace->Trace(_L("Session Id : "), KTraceFileName, __LINE__); + TBuf<64> sessionId; + sessionId.AppendNum(iSETSessionUniqueId); + iTrace->Trace(sessionId, KTraceFileName, __LINE__); + + TInt err=iSuplStorageSettings->InsertSessionRecord(activeSessionParam); + CleanupStack::PopAndDestroy(activeSessionParam); + } + +// ----------------------------------------------------------------------------- +// COMASuplSession::RemoveActiveSession +// +// +// ----------------------------------------------------------------------------- +void COMASuplSession::RemoveActiveSession() + { + iTrace->Trace(_L("Removing Trigger Session from DB..."), KTraceFileName, __LINE__); + //may need to reset the iActiveSessionId to 0 so that self deletion event will not come to same session... + TInt err = iSuplStorageSettings->DeleteSessionRecord(iSETSessionUniqueId); + } + +void COMASuplSession::UpdateActiveTriggerSession() +{ + iTrace->Trace(_L("Updating Trigger Session into DB..."), KTraceFileName, __LINE__); + iTrace->Trace(_L("Session Id : "), KTraceFileName, __LINE__); + TBuf<64> sessionId; + sessionId.AppendNum(iSETSessionUniqueId); + iTrace->Trace(sessionId, KTraceFileName, __LINE__); + + TInt err = iSuplStorageSettings->SetOutstandingTriggers(iSETSessionUniqueId,iNumFixes); +} + +// ----------------------------------------------------------------------------- +// COMASuplSession::AreYouHandlingThisSession +// +// +// ----------------------------------------------------------------------------- +TBool COMASuplSession::AreYouHandlingThisSession(TInt64& aActiveSessionId) + { + //We will consider only Network Initiated case,as there will be cancellation of only network initiated trigger only, nor SET initiated. + //return ((aActiveSessionId == iSETSessionUniqueId) && (iRequestType == ESUPL_NETWORK)); + return (aActiveSessionId == iSETSessionUniqueId); + } + + +void COMASuplSession::LaunchNotifyDialogL() +{ + + iTrace->Trace(_L("COMASuplSession2::LaunchNotifyDialogL..."), KTraceFileName, __LINE__); + + if (!iPrivacyOverride && iTotalNoOfFixes == (iNumFixes+1)) + { + iTrace->Trace(_L("COMASuplSession2::LaunchNotifyDialogL...inside if"), KTraceFileName, __LINE__); + // Synchronous call + if (iSuplReqInfo) + iTrace->Trace(_L("iSuplReqInfo is not null"), KTraceFileName, __LINE__); + + if (iNetworkPrivacy) + iTrace->Trace(_L("iNetworkPrivacy is not null"), KTraceFileName, __LINE__); + + //Inform UI that ,trigger session has started... + InsertActiveSessionL(); + TInt privacyId; + iNetworkPrivacy->NotifyLocationRequestL(*iSuplReqInfo, privacyId); + iTrace->Trace(_L(" Calling InsertActiveSessionL"), KTraceFileName, __LINE__); + + } + else + if (!iPrivacyOverride) + { + iTrace->Trace(_L("Launch Notify dialog second if condition"), KTraceFileName, __LINE__); + CTriggerParams* aParamValues = CTriggerParams::NewL(); + iSuplStorageSettings->GetTriggerParams(iSETSessionUniqueId,aParamValues); + TInt64 sessionId; + TBool notificationPresent; + TBool triggerNotificationStatus; + CTriggerParams::TTriggerType triggerType; + CTriggerParams::TRequestType requestType; + TUint64 outstandingTrigger; + TUint64 interval; + + HBufC* sessionName = HBufC::NewL( KMaxSessionNameLength ); + + aParamValues->Get(sessionId,sessionName->Des(),notificationPresent,triggerNotificationStatus, + triggerType,requestType,outstandingTrigger,interval); + //triggerNotificationStatus = ETrue; + + UpdateActiveTriggerSession(); //Update UI for trigger info... + + if (triggerNotificationStatus) + { + iTrace->Trace(_L("calling notifylocreqL in second if"), KTraceFileName, __LINE__); + if (iSuplReqInfo) + iTrace->Trace(_L("iSuplReqInfo is not null"), KTraceFileName, __LINE__); + + if (iNetworkPrivacy) + iTrace->Trace(_L("iNetworkPrivacy is not null"), KTraceFileName, __LINE__); + + + + iNetworkPrivacy->NotifyLocationRequestL(*iSuplReqInfo, iRequestorId); + + } + + delete sessionName; + delete aParamValues; + + + } + +} + +TUint COMASuplSession::GetPortNumUsed() +{ + return iPortNum; +} + +//End of File