--- /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; i<count && i<KAsn1RrlpMaxSatNumber; i++)
+ {
+ RGpsTowAssistBuilder towAssistBuilder;
+ towAssistArrayBuilder.GetFieldBuilder(i, towAssistBuilder);
+
+ ASN1T_GPSTOWAssistElement* towElement = (ASN1T_GPSTOWAssistElement*)towAssistArray.get(i);
+ TUint satId = towElement->satelliteID;
+ 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 ; i<count && i<KAsn1RrlpMaxSatNumber; ++i)
+ {
+ // Fetch a GpsNavigationModelSatInfo data item.
+ RNavigationModelSatInfoBuilder navigationModelSatInfoBuilder;
+ navigationModelSatInfoArrayBuilder.GetFieldBuilder(i, navigationModelSatInfoBuilder);
+
+ // ASN1T_ControlHeader
+ // Fetch the received satellite info
+ ASN1T_NavModelElement* satInfo = (ASN1T_NavModelElement*)satInfoArray.get(i);
+
+ WriteNavigationModelSatInfo(&navigationModelSatInfoBuilder, *satInfo);
+ }
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteNavigationModelData() End\n");
+ }
+
+
+/**
+WriteNavigationModelSatInfo()
+
+Writes the recevieved GPS Assistance Data (Navigation Model Satellite Info Array)
+to the Assistance Data Builder.
+
+@param aGpsNavigationModelBuilder, the LBS assistance data builder
+@param aGpsData, the received/decoded gps assistance data RRLP element
+*/
+void CRrlpMessageBase::WriteNavigationModelSatInfo(RNavigationModelSatInfoBuilder* aNavigationModelSatInfoBuilder, ASN1T_NavModelElement& aSatInfo)
+ {
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteNavigationModelSatInfo() Begin\n");
+ // satellite ID, status
+ aNavigationModelSatInfoBuilder->SetField(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 ; i<count && i<KAsn1RrlpMaxSatNumber; ++i)
+ {
+ RAlmanacSatInfoBuilder almanacSatInfoBuilder;
+ almanacSatInfoArrayBuilder.GetFieldBuilder(i, almanacSatInfoBuilder);
+
+ ASN1T_AlmanacElement* almanacElement = (ASN1T_AlmanacElement*)almanacArray.get(i);
+
+ WriteAlmanacSatInfo(&almanacSatInfoBuilder, *almanacElement);
+ }
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAlmanacData() End\n");
+ }
+
+
+/**
+WriteAlmanacSatInfo()
+
+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::WriteAlmanacSatInfo(RAlmanacSatInfoBuilder* aAlmanacSatInfoBuilder, ASN1T_AlmanacElement& aAlmanacElement)
+ {
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAlmanacSatInfo() Begin\n");
+ // Almanac
+
+ // Note: no RRLP data to populate TAlmanacSatInfo::EDataID field
+ aAlmanacSatInfoBuilder->SetField(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 ; i<count && i<KAsn1RrlpMaxSatNumber; ++i)
+ {
+ RAcquisitionSatInfoBuilder acquisitionSatInfoBuilder;
+ acquisitionSatInfoArrayBuilder.GetFieldBuilder(i, acquisitionSatInfoBuilder);
+
+ ASN1T_AcquisElement* acquisAssistElement = (ASN1T_AcquisElement*)acquisAssistArray.get(i);
+
+ WriteAcquisAssistSatInfo(&acquisitionSatInfoBuilder, *acquisAssistElement);
+ }
+
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAcquisitionAssistanceData() End\n");
+ }
+
+
+/**
+WriteAcquisAssistSatInfo()
+
+Writes the recevieved GPS Assistance Data (Acquisition Assistance Satellite Info)
+to the Assistance Data Builder.
+
+@param aAcquisitionSatInfoBuilder, the LBS assistance data builder
+@param aGpsData, the received/decoded gps assistance data RRLP element
+*/
+void CRrlpMessageBase::WriteAcquisAssistSatInfo(RAcquisitionSatInfoBuilder* aAcquisitionSatInfoBuilder, ASN1T_AcquisElement& aAcquisAssistElement)
+ {
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteAcquisAssistSatInfo() Begin\n");
+ aAcquisitionSatInfoBuilder->SetField(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<count && i<KAsn1RrlpMaxSatNumber; ++i)
+ {
+ badSatArrayBuilder.SetElement(i, aGpsData.realTimeIntegrity.elem[i]);
+ }
+ SUPLLOG(ELogP1, "CRrlpMessageBase::WriteRealTimeIntegrityData() End\n");
+ }
+
+
+/**
+LeaveIfAllocErrorL()
+
+Calls User::Leave(<error code>) 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);
+ }
+