omasuplasnconverterstubimpl/src/cstubsuplposinit.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Mon, 04 Oct 2010 00:04:35 +0300
changeset 46 e1758cbb96ac
parent 0 0ce1b5ce9557
permissions -rw-r--r--
Revision: 201039 Kit: 201039

/*
 * Copyright (c) 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: Supl PosInit
 *
 */

#include <e32base.h>
#include <e32def.h> 
#include <e32cmn.h> 
#include "epos_comasuplasnbase.h"
#include "epos_comasuplasnmessagebase.h"
#include "epos_comasuplposinit.h"
#include "cstubsuplposinit.h"
#include "cstubsuplstart.h"
#include "lbs/epos_comasuplreqasstdata.h"
#include "lbs/epos_comasuplposition.h"
#include "lbs/epos_comasuplvelocity.h"
#include "lbs/epos_comasuplsetcapabilities.h"
#include "lbs/epos_comasuplpospayload.h"
#include "epos_comasuplpos.h"
#include "epos_comasuplsessionid.h"
#include "epos_comasupllocationid.h"

// -----------------------------------------------------------------------------
// CStubSuplPosInit::NewL
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
EXPORT_C CStubSuplPosInit* CStubSuplPosInit::NewL()
    {
    CStubSuplPosInit* self = new (ELeave) CStubSuplPosInit;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CStubSuplPosInit::~CStubSuplPosInit
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
EXPORT_C CStubSuplPosInit::~CStubSuplPosInit()
    {

    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::ConstructL
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::ConstructL()
    {
    COMASuplPosInit::ConstructL();
    //Allocate memory for internal usage....
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::EncodeL
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
HBufC8* CStubSuplPosInit::EncodeL(TInt& aErrorCode)
    {
    aErrorCode = 0;
    HBufC8* encodedBuffer = NULL;
    InitializeL();
    // Do actual encoding here and return encoded buffer and put appropriate error code in aErrorCode
    return encodedBuffer;
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::CStubSuplPosInit
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
CStubSuplPosInit::CStubSuplPosInit()
    {
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::InitializeL
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::InitializeL()
    {
    if (iReqAsstData)  //This parameter is optional in asn
        {
    InitializeRequestData();
        }
    if (iPosition)  //This parameter is optional in asn
        {
    InitializePosition();
        }
    if (iPosPayload)  //This parameter is optional in asn
        {
    InitializePosPayLoad();
        }
    if (iSETCapabilities)  //This parameter is mandatory in asn
        {
    InitializeSetCapabilities();
        }
    if (iLocationId)  //This parameter is mandatory in asn
        {
    InitializeLocationId();
        }
    if (ieCID)  //This parameter is optional in asn
        {
    InitializeECellId();
        }
    }
void CStubSuplPosInit::InitializeRequestData()
    { 
    TBool almanac;
    TBool utc;
    TBool ionos;
    TBool dgps;
    TBool ref;
    TBool refTime;
    TBool acq;
    TBool realTime; 
    iReqAsstData->GetReqAsstData(almanac,utc,ionos,dgps,ref,refTime,acq,realTime);
    //Initialize structure here...
    }
void CStubSuplPosInit::InitializePosition()
    {
    // Retrieve mandatory parametrs of Position
    // Retrieve mandatory parametrs of Position
    TOMASuplUtcTime utcTime;
    TOMASuplPositionEstimate posEstimate;

    iPosition->GetPosition(utcTime,posEstimate );

    TInt error = 0;

    //Initialize Time
    InitializeTime(utcTime);
    //InitializePositionEstimate
    
    InitializePositionEstimate(posEstimate);
    
    if(error)
        {
        return;
        }
    else
        {
        COMASuplVelocity* velocity = NULL;
        error = iPosition->GetVelocity(velocity);
        if(error)
            {
            
            }
        else
            {

            TOMASuplVelocityType velocityType = velocity->VelType();
            COMASuplHorizVelocity* horizVelocity = velocity->Velocity();
            if(horizVelocity)
                {
                switch(velocityType)
                    {
                    case EHorizVelocity:
                        {
                        //Initialize Horizontal velocity
                        IntializeHorizVelocity(horizVelocity);
                        break;      
                        }
                    case EHorizAndVertVelocity:
                        {
                        //Initialize Horizontal and Vertical velocity
                        IntializeHorizAndVertVelocity(horizVelocity);
                        break;
                        }
                    case EHorizUncertVelocity:
                        {
                        //Initialize Horizontal Uncert velocity
                        IntializeHorizUncertVelocity(horizVelocity);
                        break;
                        }
                    case EHorizAndVertUncertVelocity:
                        {
                        //Initialize Horizontal Vertical Uncert velocity
                        IntializeHorizVertUncertVelocity(horizVelocity);
                        break;  
                        }
                    default:
                        {
                        //error
                        return;         
                        }
                    }   
                }
            else
                {
                //error
                return; 
                }
            }
        }
    }

void CStubSuplPosInit::IntializeHorizVelocity(const COMASuplHorizVelocity* aVelocity)
    {
    TUint16 bearing;
    TUint16 horSpeed;

    aVelocity->GetHorizVel(bearing,horSpeed);

    //Initialize bearing,horSpeed
    }

void CStubSuplPosInit::IntializeHorizAndVertVelocity(const COMASuplHorizVelocity* aVelocity)
    {
    TUint16 bearing;
    TUint16 horSpeed;
    TUint8 verDirect;
    TUint8 verSpeed;
    
    COMASuplHorizAndVertVelocity* horizVertVel = (COMASuplHorizAndVertVelocity*)aVelocity;

    horizVertVel->GetHorizAndVertVel(bearing,horSpeed,verDirect,verSpeed);

    //Initialize bearing,horSpeed,verDirect,verSpeed
    }

void CStubSuplPosInit::IntializeHorizUncertVelocity(const COMASuplHorizVelocity* aVelocity)
    {
    TUint16 bearing;
    TUint16 horSpeed;
    TUint8 uncertSpeed;

    COMASuplHorizUncertVelocity* horizUncertVel = (COMASuplHorizUncertVelocity*)aVelocity;

    horizUncertVel->GetHorizUncertVel(bearing,horSpeed,uncertSpeed);
    //Initialize bearing,horSpeed,uncertSpeed
    }

void CStubSuplPosInit::IntializeHorizVertUncertVelocity(const COMASuplHorizVelocity* aVelocity)
    {
    TUint16 bearing;
    TUint16 horSpeed;
    TUint8  verDirect;
    TUint8  verSpeed;
    TUint8  horizUncertSpeed;
    TUint8  vertUncertSpeed;

    COMASuplHorizAndVertUncertVelocity* horizVertUncertVel = (COMASuplHorizAndVertUncertVelocity*)aVelocity;

    horizVertUncertVel->GetHorizVertUncertVel(bearing,horSpeed,verDirect,verSpeed,
            horizUncertSpeed,vertUncertSpeed);
    //Initialize bearing,horSpeed,verDirect,verSpeed,horizUncertSpeed,vertUncertSpeed
    }

void CStubSuplPosInit::InitializePosPayLoad()
    {   
    // Retrieve mandatory parametrs of PosMessage
    COMASuplPosPayload::TOMASuplPosPayloadType payloadType;
    HBufC8* payloadData = NULL;

    iPosPayload->GetPosPayload(payloadData,payloadType);

    if(!payloadData)  
        {
        //error
        return; 
        }

    TPtr8 ptr = payloadData->Des();

    TInt len = payloadData->Length();

    const char* lTemp = (const char *)ptr.Ptr();


    switch(payloadType)
        {
        case COMASuplPosPayload::ETIA801:
            {
            //initialize pospayload for TIA   
            break;
            }   
        case COMASuplPosPayload::ERRC:
            {
            //initialize pospayload for RRC
            break;                      
            }
        case COMASuplPosPayload::ERRLP:
            {
            //initialize pospayload for RRLP
            break;                      
            }
        default:
            {
            //error
            return;
            }           
        }

    }
void CStubSuplPosInit::InitializeSetCapabilities()
    {
    TOMASuplPosTechnology lPosTechnology;
    COMASuplSETCapabilities::TOMASuplPrefMethod    lPrefMethod;
    TOMASuplPosProtocol   lPosProtocol;

    iSETCapabilities->GetSETCapabilities(lPosTechnology,lPrefMethod,lPosProtocol);

    TBool lSETAssist;
    TBool lGpsSETBased;
    TBool lAuto;
    TBool lFLT;
    TBool leOTD;
    TBool loTDOA;

    lPosTechnology.GetPosTechnology(lSETAssist,lGpsSETBased,lAuto,
            lFLT,leOTD,loTDOA);

    //Initialize structure accordingly from here...
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::InitializeLocationId
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::InitializeLocationId()
    {
    COMASuplLocationId::TOMASuplCellInfoType lChoice = iLocationId->SuplCellInfoType();

    switch(lChoice)
        {
        case COMASuplLocationId::EGSM :
            {
            COMASuplGSMCellInfo* lCellInfo = NULL;
            COMASuplLocationId::TOMASuplStatus lStatus;
            iLocationId->SuplLocationId(lCellInfo,lStatus);
            if(lCellInfo)
                {
                TInt lRefMNC;
                TInt lRefMCC;
                TInt lRefLAC;
                TInt lRefCI;
                lCellInfo->SuplGSMCellInfo(lRefMNC,lRefMCC,lRefCI,lRefLAC);
                }
            }
        case COMASuplLocationId::EWCDMA:
            {
            COMASuplCellInfo* lCellInfo = NULL;
            COMASuplLocationId::TOMASuplStatus lStatus;
            iLocationId->SuplLocationId(lCellInfo,lStatus);
            if(lCellInfo)
                {
                TInt lRefMNC;
                TInt lRefMCC;
                TInt lRefUC;
                lCellInfo->SuplCellInfo(lRefMNC,lRefMCC,lRefUC);
                if((KMncMin<=lRefMNC && lRefMNC<=KMncMax) && (KMccMin<=lRefMCC && lRefMCC<=KMccMax) &&
                        (KRefUcMin<=lRefUC && lRefUC<=KRefUcMax))
                    {
                    //Initialize  
                    }
                }
            else
                {
                //error    
                }

            }
        }
    //Initialize structure accordingly from here...
    }

// -----------------------------------------------------------------------------
// CStubSuplPosInit::InitializeECellId
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::InitializeECellId()
    {
    TOMASuplNwMode nwMode = iMmCellInfo.NetworkMode();

    if (nwMode == EOMASuplGSM)
        {
        InitializeGSMECellId();
        }
    else
        {
        InitializeWCDMAECellId();
        }
    //Initialize structure accordingly...
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::InitializeGSMECellId
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::InitializeGSMECellId()
    {
    TOMASuplGSMCellinfo  omaSuplGSMCellinfo;
    iMmCellInfo.GSMCellInfo(omaSuplGSMCellinfo);
    if(KOMASuplOptionalParamNotSet != omaSuplGSMCellinfo.iTA)
        {
        if(KTAMin <= omaSuplGSMCellinfo.iTA && omaSuplGSMCellinfo.iTA <= KTAMax)
            {
            //Initialize
            }
        else
            {
            //error
            }
        }       
    else
        {
        }

    TOMASuplNmr Nmr;
    TInt ARFCN;
    TInt BSIC;
    TInt RxLEV;
    
    for(TInt i = 0; i < KOMASUPLMaxNmrAmount; i++)
        {
        Nmr = omaSuplGSMCellinfo.iNmr[i];
        ARFCN = Nmr.iARFCN; // 0 to 1023  
        BSIC = Nmr.iBSIC;   // 0 to 63    
        RxLEV = Nmr.iRxLEV; // 0 to 63   

        if(ARFCN == KOMASuplOptionalParamNotSet && BSIC == KOMASuplOptionalParamNotSet &&  RxLEV ==  KOMASuplOptionalParamNotSet ) 
            {
                //error
                return;
            }

        if(KARFCNMin <= ARFCN && ARFCN <= KARFCNMax && 
                KBSICMin  <= BSIC  && BSIC  <= KBSICMax  &&
                KRxLEVMin <= RxLEV && RxLEV <= KRxLEVMax)
            {
            //initialize
            }
        else
            {
						//error
            return;
            }   

        }
    }
// -----------------------------------------------------------------------------
// CStubSuplPosInit::InitializeWCDMAECellId
// Other Items were commented in a header
// -----------------------------------------------------------------------------
//
void CStubSuplPosInit::InitializeWCDMAECellId()
    {
    TOMASuplWCDMACellinfo  omaSuplWCDMACellinfo;
    iMmCellInfo.WCDMACellInfo(omaSuplWCDMACellinfo);
    if(KOMASuplOptionalParamNotSet != omaSuplWCDMACellinfo.iPrimaryScrambilingCode) // means PrimaryScrambilingCode is filled
        {
        if(KPrimaryScrambilingCodeMin <= omaSuplWCDMACellinfo.iPrimaryScrambilingCode && omaSuplWCDMACellinfo.iPrimaryScrambilingCode <= KPrimaryScrambilingCodeMax)
            {
            //Initialize
            }
        else
            {
            //error
            }
        }       
    else
        {
        //error
        }
    
    FillFrequencyInfo(omaSuplWCDMACellinfo.iFrequencyInfo);
                
    FillMeasuredResultsList(omaSuplWCDMACellinfo.iNwkMeasureReport);   
    }

TInt CStubSuplPosInit::FillFrequencyInfo(TOMASuplFrequencyInfo& aOMASuplFrequencyInfo)
    {
    TInt    FddUL = aOMASuplFrequencyInfo.iFddUL;       // 0..16383     In case of fdd( iFddUL, iFddDL),
    TInt    FddDL = aOMASuplFrequencyInfo.iFddDL;       // 0..16383     iFddUL is optional while iFddDL is mandatory. 
    TInt    TddDt = aOMASuplFrequencyInfo.iTddNt;       // 0..16383     

    TInt retError = KErrNone;   

    if(FddDL != KOMASuplOptionalParamNotSet ) //means FddDL is provided...
    {
    if(KFddDLMin <= FddDL && FddDL <= KFddDLMax)
        {
        //Initialize here..
        }
    else
        {
        //error
        }
    }
    else
        {
            //error
        }

    FillFrequencyInfoULInfo(FddUL,retError);

    FillFrequencyInfoDT(TddDt,retError);

    return 0;
    }

void CStubSuplPosInit::FillFrequencyInfoULInfo(TInt aFddUL,TInt& aRetErrorCode)
    {
    if(aFddUL != KOMASuplOptionalParamNotSet && aRetErrorCode == KErrNone )
        {
        if(KFddULMin <= aFddUL && aFddUL <= KFddULMax)
            {
            //set to message
              aRetErrorCode = KErrNone;
            }
        else
            {     
            //error   
            }
        }                                                                       
    }

void CStubSuplPosInit::FillFrequencyInfoDT(TInt aTddDt,TInt& aRetErrorCode)
    {
    if(aTddDt != KOMASuplOptionalParamNotSet ) //means TddDt is provided...
        {
        if(KTddDtMin <= aTddDt && aTddDt <= KTddDtMax)
            {
            //Initialize
            }
        else
            {
            //error
            }
        }
    else
        {
         //error
        }
    aRetErrorCode = KErrNone;
    }

TInt CStubSuplPosInit::FillMeasuredResultsList(TOMASuplNetworkMeasureReport aNwkMeasureReport[])
    {
    
    
    for(TInt i = 0; i < KOMASUPLMaxNetworkMeasureReports; i++ )
        {
        TOMASuplNetworkMeasureReport NwkMeasureReport = aNwkMeasureReport[i];
        TInt err = FillFrequencyInfo(NwkMeasureReport.iFrequencyInfo);                

        if(KOMASuplOptionalParamNotSet != NwkMeasureReport.iCarrierRSSI) // means iCarrierRSSI is filled
            {
            if(KCarrierRSSIMin <= NwkMeasureReport.iCarrierRSSI && NwkMeasureReport.iCarrierRSSI <= KCarrierRSSIMax)
                {  
                //initialize
                }
            else
                {
                //error
                }
            }       

        err = FillCellMeasuredResult(NwkMeasureReport.iCellMeasuredResult);               
        }
    return 0;
    }

TInt CStubSuplPosInit::FillCellMeasuredResult(TOMASuplCellMeasuredResult aCellMeasuredResult[])
    {
    
    TInt eleCount = 0;
    for(TInt i = 0; i < KOMASUPLMaxCellMeasuredResults; i++ )
        {
        TOMASuplCellMeasuredResult  CellMeasuredResult = aCellMeasuredResult[i];
        TInt err = FillModeSpecificInfo(CellMeasuredResult);
        if( err == KErrNone)
            {
            //Initialize

            if(CellMeasuredResult.iCID != KOMASuplOptionalParamNotSet) // CID is present
                {
                if(KCIDMin <= CellMeasuredResult.iCID && CellMeasuredResult.iCID <= KCIDMax)
                    {
                    //Set to message                                
                    }
                else
                    {
                       //error
                    }
                }
            else
                {
                    //error
                }
            eleCount++;
            }           
        }


    if(eleCount != 0 )
        return KErrNone;
    else
        return KErrArgument; 
    }

TInt CStubSuplPosInit::FillModeSpecificInfo(TOMASuplCellMeasuredResult&  aCellMeasuredResult)
    {

    TOMASuplFddInfo     FddInfo = aCellMeasuredResult.iFddInfo;
    TOMASuplTddInfo     TddInfo = aCellMeasuredResult.iTddInfo;

    if(FddInfo.iPrimaryCPICH != KOMASuplOptionalParamNotSet) // iPrimaryCPICH is present
        {

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////              
        if(KPrimaryCPICHMin <= FddInfo.iPrimaryCPICH && FddInfo.iPrimaryCPICH <= KPrimaryCPICHMax)
            {
            //Set to message   
            //initialize
            }
        else
            {
               //error
            }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                  

        if(FddInfo.iCpichEcN0 != KOMASuplOptionalParamNotSet) // iCpichEcN0 is present
            {
            if(KCpichEcN0Min <= FddInfo.iCpichEcN0 && FddInfo.iCpichEcN0 <= KCpichEcN0Max)
                {
                //Set to message                                
                }
            else
                {
                    //error
                }
            }       
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                                              

        if(FddInfo.iCichRscp != KOMASuplOptionalParamNotSet) // iCichRscp is present
            {
            if(KCichRscpMin <= FddInfo.iCichRscp && FddInfo.iCichRscp <= KCichRscpMax)
                {
                //Set to message                                
                }
            else
                {
                    //error
                }
            }       
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                  

        if(FddInfo.iPathloss != KOMASuplOptionalParamNotSet) // iPathloss is present
            {
            if(KPathlossMin <= FddInfo.iPathloss && FddInfo.iPathloss <= KPathlossMax)
                {
                //Set to message                                
                }
            else
                {
                    //error
                }
            }       
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                  
        return KErrNone;            
        }
    else
        {
            //error
        }

    if(TddInfo.iCellParamID != KOMASuplOptionalParamNotSet) // iCellParamID is present
        {
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                 
        if(KCellParamIDMin <= TddInfo.iCellParamID && TddInfo.iCellParamID <= KCellParamIDMax)
            {
            //Set to message
            }
        else
            {
                //error
            }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                                                         

        if(TddInfo.iProposedTGSN != KOMASuplOptionalParamNotSet) // iProposedTGSN is present
            {
            if(KProposedTGSNMin <= TddInfo.iProposedTGSN && TddInfo.iProposedTGSN <= KProposedTGSNMax)
                {
                //Set to message    
                }
            else
                {
                    //error
                }
            }       

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                                                         

        if(TddInfo.iPrimaryCcpchRscp != KOMASuplOptionalParamNotSet) // iPrimaryCcpchRscp is present
            {
            if(KPrimaryCcpchRscpMin <= TddInfo.iPrimaryCcpchRscp && TddInfo.iPrimaryCcpchRscp <= KPrimaryCcpchRscpMax)
                {
                //Set to message           
                }
            else
                {
                    //error
                }
            }       

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                                                         

        if(TddInfo.iPathloss != KOMASuplOptionalParamNotSet) // iPathloss is present
            {
            if(KPathlossMin <= TddInfo.iPathloss && TddInfo.iPathloss <= KPathlossMax)
                {
                //Set to message                                
                }
            else
                {
                   //error
                }
            }       
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                  
        TInt eleCount = 0; 
        for(TInt i = 0; i < KOMASUPLMaxTimeSlotIscpAmount; i++)
            {
            if(TddInfo.iTimeslotISCP[i] != KOMASuplOptionalParamNotSet && KTimeslotISCPMin <= TddInfo.iTimeslotISCP[i] && TddInfo.iTimeslotISCP[i] <= KTimeslotISCPMax)
                {
                //Set to message                                
                //Set to message that its not optional
                eleCount++;
                }
            else
                {
                    //error
                }

            }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////                                                  
        //       
        return KErrNone;
        }
    else
        {
            //error
        }
    return 0;
    }

void CStubSuplPosInit::InitializePositionEstimate(TOMASuplPositionEstimate& aPosEstimate)
    {
    TInt error;

    // Retrieve mandatory parametrs of Position Estimate
    TOMASuplPositionEstimate::TOMASuplLatitudeSign  latSign;
    TInt               latitude;
    TInt               longitude;
    aPosEstimate.GetPositionEstimate(latSign,latitude,longitude);   

    // Set Position Estimate
    if(KLatitudeMin <= latitude && latitude <= KLatitudeMax)
        {
        //Initialize
        }
    else
        {
        //error
        }

    if(KLongitudeMin <= longitude && longitude <= KLongitudeMax)
        {
        //Initialize
        }
    else
        {
        //error
        }

    //Initialize

    // Retrieve optional parametrs of Position Estimate
    // Retrieve Uncertainity
    TOMASuplUncertainty uncertainty;
    error = aPosEstimate.GetUncertainty(uncertainty);
    if(!error)
        {    
        TInt uncertSemiMajor;
        TInt uncertSemiMinor;
        TInt orientMajorAxis;
        uncertainty.GetUncertainty(uncertSemiMajor,uncertSemiMinor,orientMajorAxis);
        if((KUncertSemiMajorMin <= uncertSemiMajor && uncertSemiMajor<= KUncertSemiMajorMax)
                && (KUncertSemiMinorMin <= uncertSemiMinor && uncertSemiMinor<= KUncertSemiMinorMax)
                && (KOrientMajorAxisMin <= orientMajorAxis && orientMajorAxis<= KOrientMajorAxisMax))
            {
            //Initialize
            }
        else
            {
            //error
            }
        }
    else
        {
        //return error
        }

    // Retrieve Confidence
    TInt confidence;
    error = aPosEstimate.GetConfidence(confidence);
    if(!error)
        {

        if(KConfidenceMin <= confidence && confidence <= KConfidenceMax)
            {
            //Initialize       
            }
        else
            {
            //error 
            }
        }
    else
        {
        //return error
        }

    // Retrieve AltitudeInfo
    TOMASuplAltitudeInfo altitudeInfo;
    error = aPosEstimate.GetAltitudeInfo(altitudeInfo);
    if(!error)
        {

        TOMASuplAltitudeInfo::TOMASuplAltitudeDirection altDirection;
        TInt altitude;
        TInt altUncert;
        altitudeInfo.GetAltitudeInfo(altDirection,altitude,altUncert);
        if((KAltitudeMin <= altitude && altitude<= KAltitudeMax) && (KAltitudeUncertMin <= altUncert && altUncert<= KAltitudeUncertMax))
            {
            //Initialize
            }
        else
            {
            //error
            }
        }
    else
        {
        //return error
        }
    }

void CStubSuplPosInit::InitializeTime(const TOMASuplUtcTime aUtcTime)
    {
    
    TDateTime lDateTime;
    TInt      zoneCode;
    TInt      zone;
    
    aUtcTime.GetUtcTime(lDateTime,zoneCode,zone);
    
    TInt   year     = lDateTime.Year();
    TMonth month    = lDateTime.Month(); 
    TInt   day      = lDateTime.Day();
    TInt   hour     = lDateTime.Hour();
    TInt   minute   = lDateTime.Minute();
    TInt   second   = lDateTime.Second();
    TInt   microsec = lDateTime.MicroSecond();
    
    if(0 == zoneCode || 1 == zoneCode)
        {
        //Initialize 
        }
    else
        {
        //error
        }
    
    
    }