diff -r 87622fad6b51 -r a796fdeeb33c networkprotocolmodules/common/suplrrlpasn1/src/rrlpmessagebase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkprotocolmodules/common/suplrrlpasn1/src/rrlpmessagebase.cpp Wed Oct 13 16:07:50 2010 +0300 @@ -0,0 +1,1000 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +/** + @file + @internalTechnology + +*/ + +#include "RRLP-Messages.h" +#include "rrlpmessagebase.h" +#include "supldevloggermacros.h" + + +/** +Const definition for the 3D location with uncertainty identifier. +This is the form of location description allowed in RRLP for the +GPS Reference Location element. +*/ +const TUint K3DLocationWithUncertainty = 9; + + +/** +Maximun number of assistance data "elements" (be it almanac, +acquisition, etc) that can be passed on to LBS. If an RRLP +message contains more elements than the maximum, only the +first 32 are considered. +*/ +const TUint8 KAsn1RrlpMaxSatNumber = 32; + +/** +Const definition for multiplier to convert 0.08 second resolution to ms.. +The Reference Time field of the GPS Assistance Data element contains +a GPS Time Of Week (TOW) element, with resolution 0.08seconds. +The LBS Assistance Data object stores the TOW in ms. +*/ +const TUint KGpsTowMultiplier = 80; + +/** +Constructor +*/ +CRrlpMessageBase::CRrlpMessageBase(TSuplPosPayloadType aType, TBool aIsOutgoingMsg) + : CSuplPosPayload(aType, aIsOutgoingMsg) + { + } + + +/** +Second stage constructor + +Outgoing messages: constructs the data encapsulation and control objects. +Incoming message: no action +*/ +void CRrlpMessageBase::ConstructL() + { + if (iIsOutgoingMessage) + { + iData = new (ELeave) ASN1T_PDU(); + ASN1Context* context = new (ELeave) ASN1Context; + CleanupDeletePushL(context); + iControl = new (ELeave) ASN1C_PDU(*context, *iData); + // construction of iControl successful, pop context off the cleanup stack + CleanupStack::Pop(context); + } + } + + +/** +Destructor +*/ +CRrlpMessageBase::~CRrlpMessageBase() + { + SUPLLOG(ELogP1, "CRrlpMessageBase::~CRrlpMessageBase() Begin\n"); + delete iEncodeBuffer; + delete iData; + delete iControl; + // release the STDLIB resources associated with this thread + CloseSTDLIB(); + SUPLLOG(ELogP1, "CRrlpMessageBase::~CRrlpMessageBase() End\n"); + } + + +/** +SetDecodedData() + +Assign decoded ASN1 data, for received messages. +Takes ownership of passed objects. + +@param aData data structure containing decoded message parameters +@param aControl control structure associated with decoded data structure. +*/ +void CRrlpMessageBase::SetDecodedData(ASN1T_PDU* aData, ASN1C_PDU* aControl) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::SetDecodedData() Begin\n"); + __ASSERT_DEBUG(!iIsOutgoingMessage, User::Invariant()); + __ASSERT_DEBUG(iData == NULL, User::Invariant()); + __ASSERT_DEBUG(iControl == NULL, User::Invariant()); + iData = aData; + iControl = aControl; + SUPLLOG(ELogP1, "CRrlpMessageBase::SetDecodedData() End\n"); + } + + +/** +SetReference() + +Sets the RRLP session reference +Messages that contain the Rel-5 Extended Reference override the method +SetExtendedReference() to populate this content. + +The RRLP Reference, including the Rel-5 extended reference include the +following parameters + TInt aRefNum; // 0..7 + TBool aRel5EntendedRefPresent; + TInt aRel5SmlcCode; // 0..63 + TInt aRel5TransactionId; // 0..262143 + +@param aRrlpRef local copy of the session reference details +@return error indication, KErrNone otherwise +*/ +EXPORT_C TInt CRrlpMessageBase::SetReference(const TRrlpReference& aRrlpRef) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::SetReference() Begin\n"); + __ASSERT_DEBUG(iIsOutgoingMessage, User::Invariant()); + __ASSERT_DEBUG(iData != NULL, User::Invariant()); + + iData->referenceNumber = aRrlpRef.aRefNum; + + TInt err = KErrNone; + err = SetExtendedReference(aRrlpRef); + if (err == KErrNotFound) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::SetReference() no extended reference present\n"); + } + + + SUPLLOG(ELogP1, "CRrlpMessageBase::SetReference() End\n"); + return KErrNone; + } + + +/** +SetExtendedReference() + +Overridden by derived classes representing messages that include rel-5 +extended reference. + +@param aRrlpRef local copy of the session reference details +@return error indication, KErrNone otherwise +*/ +TInt CRrlpMessageBase::SetExtendedReference(const TRrlpReference& /*aRrlpRef*/) + { + return KErrNone; + } + + +/** +Reference() + +Populates aRrlpRef with the session reference + +@param aRrlpRef on return, populated with the session reference details +@return error indication, KErrNone otherwise +*/ +EXPORT_C TInt CRrlpMessageBase::GetReference(TRrlpReference& aRrlpRef) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::Reference() Begin\n"); + __ASSERT_DEBUG(iData != NULL, User::Invariant()); + aRrlpRef.aRefNum = iData->referenceNumber; + + TInt err = KErrNone; + err = GetExtendedReference(aRrlpRef); + if (err == KErrNotFound) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::Reference() no extended reference present\n"); + } + + SUPLLOG(ELogP1, "CRrlpMessageBase::Reference() End\n"); + return KErrNone; + } + + +/** +GetExtendedReference() + +Overridden by derived classes representing messages that include rel-5 +extended reference. + +@param aRrlpRef local copy of the session reference details +@return KErrNotFound if the extended reference parameters are not present, + KErrNone otherwise +*/ +TInt CRrlpMessageBase::GetExtendedReference(TRrlpReference& /*aRrlpRef*/) + { + return KErrNotFound; + } + + +/** +EncodeToL() + +Encode a populated outgoing message to the specified buffer. + +@param aBuf buffer pointer +@return error indication, KErrNone otherwise +*/ +EXPORT_C TInt CRrlpMessageBase::EncodeToL(TPtr8& aBuf) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::EncodeToL() Begin\n"); + __ASSERT_DEBUG(iIsOutgoingMessage, User::Invariant()); + + // buffer pointer, fixed max length + TUint8* msgBuf = (TUint8*)aBuf.Ptr(); + TInt maxLength = aBuf.MaxLength(); + + // construct the encode buffer control object + iEncodeBuffer = new (ELeave) ASN1PEREncodeBuffer (msgBuf, (unsigned int)maxLength, FALSE, (OSRTContext*)iControl->getContext()); + + // Encode the message to the buffer + TInt stat = KErrNone; + stat = iControl->EncodeTo(*iEncodeBuffer); + + TInt retval = KErrNone; + if (stat == 0) + { + // Set the length according to reported buffer length + TInt len = iEncodeBuffer->getMsgLen(); + aBuf.SetLength(len); + } + else + { + retval = ProcessAsn1Error(stat); + } + + delete iEncodeBuffer; + iEncodeBuffer = NULL; + + SUPLLOG(ELogP1, "CRrlpMessageBase::EncodeToL() End\n"); + return retval; + } + + +/** +BuildAssistanceData() + +@param aDataMask populated to indicate what assistance data has been received +@param aData reference to assistance data builder object to populate with + received assistance data +@param aGpsData the received/decoded gps assistance data RRLP element +@return error indication, KErrNone otherwise +*/ +TInt CRrlpMessageBase::BuildAssistanceData(TLbsAsistanceDataGroup& aDataMask, RLbsAssistanceDataBuilderSet& aAssistanceDataBuilderSet, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::BuildAssistanceData() Begin\n"); + // clear the data mask + aDataMask = EAssistanceDataNone; + + // Reference Time + if (aGpsData.m.referenceTimePresent) + { + SUPLLOG(ELogP1, " Reference Time received...\n"); + aDataMask |= EAssistanceDataReferenceTime; + + // Fetch a GpsReferenceTime data item. + RUEPositioningGpsReferenceTimeBuilder* gpsReferenceTimeBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsReferenceTimeBuilder); + + WriteReferenceTimeData(gpsReferenceTimeBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsReferenceTimeBuilder->SetTimeStamp(timeNow); + } + + // Reference Location + if (aGpsData.m.refLocationPresent) + { + SUPLLOG(ELogP1, " Reference Location received...\n"); + aDataMask |= EAssistanceDataReferenceLocation; + + // Fetch a ReferenceLocation data item. + RReferenceLocationBuilder* gpsReferenceLocationBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsReferenceLocationBuilder); + + WriteReferenceLocationData(gpsReferenceLocationBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsReferenceLocationBuilder->SetTimeStamp(timeNow); + } + + // DGPS Corrections + if (aGpsData.m.dgpsCorrectionsPresent) + { + SUPLLOG(ELogP1, " DGPS Corrections received, ignoring...\n"); + // never requested by LBS, no data builder available. Ignore. + } + + // Navigation Model + if (aGpsData.m.navigationModelPresent) + { + SUPLLOG(ELogP1, " Navigation Model received...\n"); + aDataMask |= EAssistanceDataNavigationModel; + + // Fetch a GpsNavigationModel data item. + RUEPositioningGpsNavigationModelBuilder* gpsNavigationModelBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsNavigationModelBuilder); + + WriteNavigationModelData(gpsNavigationModelBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsNavigationModelBuilder->SetTimeStamp(timeNow); + } + + // Ionospheric Model + if (aGpsData.m.ionosphericModelPresent) + { + SUPLLOG(ELogP1, " Ionospheric Model received...\n"); + aDataMask |= EAssistanceDataIonosphericModel; + + //Fetch a GpsIonosphericModel data item. + RUEPositioningGpsIonosphericModelBuilder* gpsIonosphericModelBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsIonosphericModelBuilder); + + WriteIonosphericModelData(gpsIonosphericModelBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsIonosphericModelBuilder->SetTimeStamp(timeNow); + } + + // UTC Model + if (aGpsData.m.utcModelPresent) + { + SUPLLOG(ELogP1, " UTC Model received...\n"); + aDataMask |= EAssistanceDataPositioningGpsUtcModel; + + //Fetch a GpsUTCModel data item. + RUEPositioningGpsUtcModelBuilder* gpsUtcModelBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsUtcModelBuilder); + + WriteUtcModelData(gpsUtcModelBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsUtcModelBuilder->SetTimeStamp(timeNow); + } + + // Almanac + if (aGpsData.m.almanacPresent) + { + SUPLLOG(ELogP1, " Almanac received...\n"); + aDataMask |= EAssistanceDataAlmanac; + + //Fetch a GpsAlmanacBuilder data builder. + RUEPositioningGpsAlmanacBuilder* gpsAlmanacBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsAlmanacBuilder); + + WriteAlmanacData(gpsAlmanacBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsAlmanacBuilder->SetTimeStamp(timeNow); + } + + // Acquisition Assistance + if (aGpsData.m.acquisAssistPresent) + { + SUPLLOG(ELogP1, " Aquisition Assistance received...\n"); + aDataMask |= EAssistanceDataAquisitionAssistance; + + //Fetch a GpsAcquisitionAssistance data builder. + RUEPositioningGpsAcquisitionAssistanceBuilder* gpsAcquisitionAssistanceBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(gpsAcquisitionAssistanceBuilder); + + WriteAcquisitionAssistanceData(gpsAcquisitionAssistanceBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + gpsAcquisitionAssistanceBuilder->SetTimeStamp(timeNow); + } + + // Real Time Integrity + if (aGpsData.m.realTimeIntegrityPresent) + { + SUPLLOG(ELogP1, " Real Time Integrity received...\n"); + aDataMask |= EAssistanceDataBadSatList; + + //Fetch a GpsBadSatList data item. + RBadSatListBuilder* badSatListBuilder; + aAssistanceDataBuilderSet.GetDataBuilder(badSatListBuilder); + + WriteRealTimeIntegrityData(badSatListBuilder, aGpsData); + + TTime timeNow; + timeNow.UniversalTime(); + badSatListBuilder->SetTimeStamp(timeNow); + } + + SUPLLOG(ELogP1, "CRrlpMessageBase::BuildAssistanceData() End\n"); + return KErrNone; + } + + +/** +WriteReferenceTimeData() + +Writes the recevieved GPS Assistance Data (Reference Time) to the Assistance +Data Builder. + +@param aReferenceTimeBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteReferenceTimeData(RUEPositioningGpsReferenceTimeBuilder* aReferenceTimeBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteReferenceTimeData() Begin\n"); + // GPS TIME elements + TUint gpsWeek = aGpsData.referenceTime.gpsTime.gpsWeek; + TUint gpsTow = aGpsData.referenceTime.gpsTime.gpsTOW23b * KGpsTowMultiplier; + aReferenceTimeBuilder->SetField(TUEPositioningGpsReferenceTime::EGpsWeek, gpsWeek); + aReferenceTimeBuilder->SetField(TUEPositioningGpsReferenceTime::EGpsTow1Msec, gpsTow); + + // GSM TIME elements (optional) + // Not currently supported by this implementation + // LBS assistance data builder support required. + + // GPS TOW ASSIST elements (optional) + if (aGpsData.referenceTime.m.gpsTowAssistPresent != 0) + { + RGpsTowAssistArrayBuilder towAssistArrayBuilder; + aReferenceTimeBuilder->GetArrayBuilder(TUEPositioningGpsReferenceTime::EGpsTowAssistArray, towAssistArrayBuilder); + + // array accessor + ASN1C_GPSTOWAssist towAssistArray(aGpsData.referenceTime.gpsTowAssist); + + TInt count = aGpsData.referenceTime.gpsTowAssist.count; + for (TInt i=0; isatelliteID; + TUint tlmMessage = towElement->tlmWord; + TBool alert = (towElement->alert !=0 ? ETrue : EFalse); + TBool antiSpoof = (towElement->antiSpoof !=0 ? ETrue : EFalse); + + towAssistBuilder.SetField(TGpsTowAssist::ESatID, satId); + towAssistBuilder.SetField(TGpsTowAssist::ETlmMessage, tlmMessage); + towAssistBuilder.SetField(TGpsTowAssist::EAlert, alert); + towAssistBuilder.SetField(TGpsTowAssist::EAntiSpoof, antiSpoof); + } + } + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteReferenceTimeData() End\n"); + } + + + +/** +WriteReferenceLocationData() + +Writes the recevieved GPS Assistance Data (Reference Location) to the Assistance +Data Builder. + +@param aReferenceLocationBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteReferenceLocationData(RReferenceLocationBuilder* aReferenceLocationBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteReferenceLocationData() Begin\n"); + // Allowed shape type is ellipsoid point with altitude and uncertainty ellipsoid + TUint shapeType = 0; + shapeType |= aGpsData.refLocation.threeDLocation.data[0]>>4; + + // handle latitude and longitude whatever the shape type + TUint latitude = 0; + latitude |= aGpsData.refLocation.threeDLocation.data[1]; + latitude = latitude<<8; + latitude |= aGpsData.refLocation.threeDLocation.data[2]; + latitude = latitude<<8; + latitude |= aGpsData.refLocation.threeDLocation.data[3]; + latitude &= 0x7FFFFF; // clear the sign of latitude bit. + + // latitude sign, 0 == north, 1 == south + TEllipsoidPointAltitudeEllipsoide::TLatitudeSign latitudeSign = TEllipsoidPointAltitudeEllipsoide::ENorth; + if ((aGpsData.refLocation.threeDLocation.data[1] & 128) != 0) + { + latitudeSign = TEllipsoidPointAltitudeEllipsoide::ESouth; + } + + TInt longitude = 0; + longitude |= aGpsData.refLocation.threeDLocation.data[4]; + longitude = longitude<<8; + longitude |= aGpsData.refLocation.threeDLocation.data[5]; + longitude = longitude<<8; + longitude |= aGpsData.refLocation.threeDLocation.data[6]; + + TUint altitude = 0; + altitude |= aGpsData.refLocation.threeDLocation.data[7]; + altitude = altitude<<8; + altitude |= aGpsData.refLocation.threeDLocation.data[8]; + + // handling of altitude and uncertainty dependant on shape type. + // note that RRLP specifies usage of 3D location with uncertainty, so + // no need to handle other types. + if (shapeType == K3DLocationWithUncertainty) + { + // altitude direction, 0 == above, 1 == below WGS84 ellipsoid + TEllipsoidPointAltitudeEllipsoide::TAltitudeDirection altitudeDirection = TEllipsoidPointAltitudeEllipsoide::EHeight; + if ((aGpsData.refLocation.threeDLocation.data[7] & 128) != 0) + { + altitudeDirection = TEllipsoidPointAltitudeEllipsoide::EDepth; + } + + // uncertainty etc... + TUint uncertSemiMaj = aGpsData.refLocation.threeDLocation.data[9]; + TUint uncertSemiMin = aGpsData.refLocation.threeDLocation.data[10]; + TUint orientation = aGpsData.refLocation.threeDLocation.data[11]; + TUint uncertAltitude = aGpsData.refLocation.threeDLocation.data[12]; + TUint confidence = aGpsData.refLocation.threeDLocation.data[13]; + + REllipsoidPointAltitudeEllipsoideBuilder ellipsoidPointAltBuilder; + aReferenceLocationBuilder->GetFieldBuilder(TReferenceLocation::EEllipsoidPointAltitudeEllipsoide, ellipsoidPointAltBuilder); + + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::ELatitudeSign, latitudeSign); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::ELatitude, latitude); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::ELongitude, longitude); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EAltitudeDirection, altitudeDirection); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EAltitude, altitude); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintySemiMajor, uncertSemiMaj); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintySemiMinor, uncertSemiMin); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EOrientationMajorAxis, orientation); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EUncertaintyAltitude, uncertAltitude); + ellipsoidPointAltBuilder.SetField(TEllipsoidPointAltitudeEllipsoide::EConfidence, confidence); + } + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteReferenceLocationData() End\n"); + } + + +/** +WriteNavigationModelData() + +Writes the recevieved GPS Assistance Data (Navigation Model) to the Assistance +Data Builder. + +@param aGpsNavigationModelBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteNavigationModelData(RUEPositioningGpsNavigationModelBuilder* aGpsNavigationModelBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteNavigationModelData() Begin\n"); + // Fetch a GpsNavigationModelSatInfoArray data item. + RNavigationModelSatInfoArrayBuilder navigationModelSatInfoArrayBuilder; + aGpsNavigationModelBuilder->GetArrayBuilder(TUEPositioningGpsNavigationModel::ENavigationModelSatelliteInfoArray, navigationModelSatInfoArrayBuilder); + + // array accessor + ASN1C_SeqOfNavModelElement satInfoArray(aGpsData.navigationModel.navModelList); + + TInt count = aGpsData.navigationModel.navModelList.count; + for (TInt i=0 ; iSetField(TNavigationModelSatInfo::ESatId, (TUint)aSatInfo.satelliteID); + aNavigationModelSatInfoBuilder->SetField(TNavigationModelSatInfo::ESatelliteStatus, (TSatelliteStatus)(aSatInfo.satStatus.t-EZeroOffsetAdjust)); + + // ephemeris data if either "new sat, new nav model" OR "existing sat, new nav model" + if (aSatInfo.satStatus.t == T_SatStatus_newSatelliteAndModelUC) + { + WriteSatInfoEphemeris(aNavigationModelSatInfoBuilder, *aSatInfo.satStatus.u.newSatelliteAndModelUC); + } + else if (aSatInfo.satStatus.t == T_SatStatus_newNaviModelUC) + { + WriteSatInfoEphemeris(aNavigationModelSatInfoBuilder, *aSatInfo.satStatus.u.newNaviModelUC); + } + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteNavigationModelSatInfo() End\n"); + } + + +/** +WriteSatInfoEphemeris() + +Writes the recevieved GPS Assistance Data (Navigation Model Satellite Info Element) +to the Assistance Data Builder. + +@param aNavigationModelSatInfoBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteSatInfoEphemeris(RNavigationModelSatInfoBuilder* aNavigationModelSatInfoBuilder, ASN1T_UncompressedEphemeris& aSatEphemeris) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteSatInfoEphemeris() Begin\n"); + REphemerisParameterBuilder ephemerisBuilder; + aNavigationModelSatInfoBuilder->GetFieldBuilder(TNavigationModelSatInfo::EEphemerisParameter, ephemerisBuilder); + + TUint value = aSatEphemeris.ephemCodeOnL2; + ephemerisBuilder.SetField(TEphemerisParameter::ECodeOnL2, value); + + value = aSatEphemeris.ephemURA; + ephemerisBuilder.SetField(TEphemerisParameter::EUraIndex, value); + + value = aSatEphemeris.ephemSVhealth; + ephemerisBuilder.SetField(TEphemerisParameter::ESatHealth, value); + + value = aSatEphemeris.ephemIODC; + ephemerisBuilder.SetField(TEphemerisParameter::EIodc, value); + + value = aSatEphemeris.ephemL2Pflag; + ephemerisBuilder.SetField(TEphemerisParameter::EL2Pflag, value); + + value = aSatEphemeris.ephemTgd; + ephemerisBuilder.SetField(TEphemerisParameter::ETGD, value); + + value = aSatEphemeris.ephemToc; + ephemerisBuilder.SetField(TEphemerisParameter::EToc, value); + + value = aSatEphemeris.ephemAF2; + ephemerisBuilder.SetField(TEphemerisParameter::EAf2, value); + + value = aSatEphemeris.ephemAF1; + ephemerisBuilder.SetField(TEphemerisParameter::EAf1, value); + + value = aSatEphemeris.ephemAF0; + ephemerisBuilder.SetField(TEphemerisParameter::EAf0, value); + + value = aSatEphemeris.ephemCrs; + ephemerisBuilder.SetField(TEphemerisParameter::ECrs, value); + + value = aSatEphemeris.ephemDeltaN; + ephemerisBuilder.SetField(TEphemerisParameter::EDeltaN, value); + + value = aSatEphemeris.ephemM0; + ephemerisBuilder.SetField(TEphemerisParameter::EM0, value); + + value = aSatEphemeris.ephemCuc; + ephemerisBuilder.SetField(TEphemerisParameter::ECuc, value); + + value = aSatEphemeris.ephemE; + ephemerisBuilder.SetField(TEphemerisParameter::EE, value); + + value = aSatEphemeris.ephemCus; + ephemerisBuilder.SetField(TEphemerisParameter::ECus, value); + + value = aSatEphemeris.ephemAPowerHalf; + ephemerisBuilder.SetField(TEphemerisParameter::EASqrt, value); + + value = aSatEphemeris.ephemToe; + ephemerisBuilder.SetField(TEphemerisParameter::EToe, value); + + value = aSatEphemeris.ephemFitFlag; + ephemerisBuilder.SetField(TEphemerisParameter::EFitInterval, value); + + value = aSatEphemeris.ephemAODA; + ephemerisBuilder.SetField(TEphemerisParameter::EAodo, value); + + value = aSatEphemeris.ephemCic; + ephemerisBuilder.SetField(TEphemerisParameter::ECic, value); + + value = aSatEphemeris.ephemOmegaA0; + ephemerisBuilder.SetField(TEphemerisParameter::EOmega0, value); + + value = aSatEphemeris.ephemCis; + ephemerisBuilder.SetField(TEphemerisParameter::ECis, value); + + value = aSatEphemeris.ephemI0; + ephemerisBuilder.SetField(TEphemerisParameter::EI0, value); + + value = aSatEphemeris.ephemCrc; + ephemerisBuilder.SetField(TEphemerisParameter::ECrc, value); + + value = aSatEphemeris.ephemW; + ephemerisBuilder.SetField(TEphemerisParameter::EOmega, value); + + value = aSatEphemeris.ephemOmegaADot; + ephemerisBuilder.SetField(TEphemerisParameter::EOmegaDot, value); + + value = aSatEphemeris.ephemIDot; + ephemerisBuilder.SetField(TEphemerisParameter::EIDot, value); + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteSatInfoEphemeris() End\n"); + } + + +/** +WriteIonosphericModelData() + +Writes the recevieved GPS Assistance Data (Ionospheric Model) to the Assistance +Data Builder. + +@param aGpsIonosphericModelBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteIonosphericModelData(RUEPositioningGpsIonosphericModelBuilder* aGpsIonosphericModelBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteIonosphericModelData() Begin\n"); + // Ionospheric Model Data + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EAlfa0, (TUint)aGpsData.ionosphericModel.alfa0); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EAlfa1, (TUint)aGpsData.ionosphericModel.alfa1); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EAlfa2, (TUint)aGpsData.ionosphericModel.alfa2); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EAlfa3, (TUint)aGpsData.ionosphericModel.alfa3); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EBeta0, (TUint)aGpsData.ionosphericModel.beta0); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EBeta1, (TUint)aGpsData.ionosphericModel.beta1); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EBeta2, (TUint)aGpsData.ionosphericModel.beta2); + aGpsIonosphericModelBuilder->SetField(TUEPositioningGpsIonosphericModel::EBeta3, (TUint)aGpsData.ionosphericModel.beta3); + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteIonosphericModelData() End\n"); + } + + +/** +WriteUtcModelData() + +Writes the recevieved GPS Assistance Data (UTC Model) to the Assistance +Data Builder. + +@param aGpsUtcModelBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteUtcModelData(RUEPositioningGpsUtcModelBuilder* aGpsUtcModelBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteUtcModelData() Begin\n"); + // Universal Time Coordinate Model + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EA1, (TUint)aGpsData.utcModel.utcA1); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EA0, (TUint)aGpsData.utcModel.utcA0); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::ETot, (TUint)aGpsData.utcModel.utcTot); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EWnt, (TUint)aGpsData.utcModel.utcWNt); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EDeltatLS, (TUint)aGpsData.utcModel.utcDeltaTls); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EWnlsf, (TUint)aGpsData.utcModel.utcWNlsf); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EDn, (TUint)aGpsData.utcModel.utcDN); + aGpsUtcModelBuilder->SetField(TUEPositioningGpsUtcModel::EDeltatLSF, (TUint)aGpsData.utcModel.utcDeltaTlsf); + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteUtcModelData() End\n"); + } + + +/** +WriteUtcModelData() + +Writes the recevieved GPS Assistance Data (UTC Model) to the Assistance +Data Builder. + +@param aGpsUtcModelBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteAlmanacData(RUEPositioningGpsAlmanacBuilder* aGpsAlmanacBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAlmanacData() Begin\n"); + + // Almanac + aGpsAlmanacBuilder->SetField(TUEPositioningGpsAlmanac::EWnA, (TUint)aGpsData.almanac.alamanacWNa); + + // source array accessor + ASN1C_SeqOfAlmanacElement almanacArray(aGpsData.almanac.almanacList); + + // Populate almanac satellite info array + RAlmanacSatInfoArrayBuilder almanacSatInfoArrayBuilder; + aGpsAlmanacBuilder->GetArrayBuilder(TUEPositioningGpsAlmanac::EAlmanacInfoSatArray, almanacSatInfoArrayBuilder); + + TInt count = aGpsData.almanac.almanacList.count; + // Copy assistance data for a maximun of KAsn1RrlpMaxSatNumber + // satellites (LBS data structures cannot accomodate more) + for (TInt i=0 ; iSetField(TAlmanacSatInfo::ESatID, (TUint)aAlmanacElement.satelliteID); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EE, (TUint)aAlmanacElement.almanacE); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EToa, (TUint)aAlmanacElement.alamanacToa); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EDeltaI, (TUint)aAlmanacElement.almanacKsii); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EOmegaDot, (TUint)aAlmanacElement.almanacOmegaDot); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::ESatHealth, (TUint)aAlmanacElement.almanacSVhealth); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EASqrt, (TUint)aAlmanacElement.almanacAPowerHalf); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EOmega0, (TUint)aAlmanacElement.almanacOmega0); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EM0, (TUint)aAlmanacElement.almanacM0); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EOmega, (TUint)aAlmanacElement.almanacW); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EAf0, (TUint)aAlmanacElement.almanacAF0); + aAlmanacSatInfoBuilder->SetField(TAlmanacSatInfo::EAf1, (TUint)aAlmanacElement.almanacAF1); + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAlmanacSatInfo() End\n"); + } + + +/** +WriteAcquisitionAssistanceData() + +Writes the recevieved GPS Assistance Data (Acquisition Assistance Data) to +the Assistance Data Builder. + +@param aGpsAcquisitionAssistanceBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteAcquisitionAssistanceData(RUEPositioningGpsAcquisitionAssistanceBuilder* aGpsAcquisitionAssistanceBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAcquisitionAssistanceData() Begin\n"); + // Aquisition Assistance + + // GSM TIME elements (optional) + // Not currently supported by this implementation + // LBS assistance data builder support required. + + // source array accessor + ASN1C_SeqOfAcquisElement acquisAssistArray(aGpsData.acquisAssist.acquisList); + + // Populate almanac satellite info array + RAcquisitionSatInfoArrayBuilder acquisitionSatInfoArrayBuilder; + aGpsAcquisitionAssistanceBuilder->GetArrayBuilder(TUEPositioningGpsAcquisitionAssistance::ESatelliteInformationArray, acquisitionSatInfoArrayBuilder); + + TInt count = aGpsData.acquisAssist.acquisList.count; + for (TInt i=0 ; iSetField(TAcquisitionSatInfo::ESatID, (TUint)aAcquisAssistElement.svid); + aAcquisitionSatInfoBuilder->SetField(TAcquisitionSatInfo::EDoppler0thOrder, (TInt)aAcquisAssistElement.doppler0); + aAcquisitionSatInfoBuilder->SetField(TAcquisitionSatInfo::ECodePhase, (TUint)aAcquisAssistElement.codePhase); + aAcquisitionSatInfoBuilder->SetField(TAcquisitionSatInfo::EIntegerCodePhase, (TUint)aAcquisAssistElement.intCodePhase); + aAcquisitionSatInfoBuilder->SetField(TAcquisitionSatInfo::EGpsBitNumber, (TUint)aAcquisAssistElement.gpsBitNumber); + aAcquisitionSatInfoBuilder->SetField(TAcquisitionSatInfo::ECodePhaseSearchWindow, (TCodePhaseSearchWindow)aAcquisAssistElement.codePhaseSearchWindow); + + if (aAcquisAssistElement.m.addionalDopplerPresent != 0) + { + RExtraDopplerInfoBuilder extraDopplerInfoBuilder; + aAcquisitionSatInfoBuilder->GetFieldBuilder(TAcquisitionSatInfo::EExtraDopplerInfo, extraDopplerInfoBuilder); + extraDopplerInfoBuilder.SetField(TExtraDopplerInfo::EDoppler1stOrder, (TInt)aAcquisAssistElement.addionalDoppler.doppler1); + extraDopplerInfoBuilder.SetField(TExtraDopplerInfo::EDopplerUncertainty, (TDopplerUncertainty)aAcquisAssistElement.addionalDoppler.dopplerUncertainty); + } + + if (aAcquisAssistElement.m.addionalAnglePresent) + { + RTAzimuthAndElevationBuilder azimuthAndElevationBuilder; + aAcquisitionSatInfoBuilder->GetFieldBuilder(TAcquisitionSatInfo::EAzimuthAndElevation, azimuthAndElevationBuilder); + azimuthAndElevationBuilder.SetField(TAzimuthAndElevation::EAzimuth, (TUint)aAcquisAssistElement.addionalAngle.azimuth); + azimuthAndElevationBuilder.SetField(TAzimuthAndElevation::EElevation, (TUint)aAcquisAssistElement.addionalAngle.elevation); + } + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAcquisAssistSatInfo() End\n"); + } + + +/** +WriteRealTimeIntegrityData() + +Writes the recevieved GPS Assistance Data (Real Time Integrity) to the +Assistance Data Builder. + +@param aBadSatListBuilder, the LBS assistance data builder +@param aGpsData, the received/decoded gps assistance data RRLP element +*/ +void CRrlpMessageBase::WriteRealTimeIntegrityData(RBadSatListBuilder* aBadSatListBuilder, ASN1T_ControlHeader& aGpsData) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::WriteRealTimeIntegrityData() Begin\n"); + // Real Time Integrity + RBadSatArrayBuilder badSatArrayBuilder; + aBadSatListBuilder->GetArrayBuilder(TBadSatList::EBadSatIdArray, badSatArrayBuilder); + + TInt count = aGpsData.realTimeIntegrity.n; + + for (TInt i=0 ; i) if a memory allocation has failed. +*/ +void CRrlpMessageBase::LeaveIfAllocErrorL() + { + SUPLLOG(ELogP1, "CRrlpMessageBase::LeaveIfAllocErrorL() Begin\n"); + if (iControl->getStatus() == RTERR_NOMEM) + { + User::Leave(KErrNoMemory); + } + else if (iControl->getStatus() != RT_OK) + { + User::Leave(KErrGeneral); + } + SUPLLOG(ELogP1, "CRrlpMessageBase::LeaveIfAllocErrorL() End\n"); + } + + +/** +Translates error codes returned by the ASN1 runtime library to distinguish +from Symbian global error codes. + +Errors are simply translated to positive error codes. They maintain their +meaning as described in rtxErrCodes.h and asn1ErrCodes.h. + +Exceptions: + RTERR_NOMEM is translated to global error code KErrNoMemory + +@see rtxErrCodes.h +@see asn1ErrCodes.h +*/ +TInt CRrlpMessageBase::ProcessAsn1Error(TInt aError) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::ProcessAsn1Error() Begin\n"); + if (aError == RTERR_NOMEM) + { + SUPLLOG(ELogP1, "CRrlpMessageBase::ProcessAsn1Error() End (Out Of Memory)\n"); + return KErrNoMemory; + } + else + { + SUPLLOG2(ELogP1, "CRrlpMessageBase::ProcessAsn1Error() End (ASN1Error runtime error %d)\n", aError); + return aError * -1; + } + } + +/** +Prints the content payload data structure to the logger +*/ +void CRrlpMessageBase::LogMessageContent() + { + SUPLLOG(ELogP9, "RRLP PAYLOAD CONTENT\n"); + //SUPLLOG_PDU(iControl); + } +