/*

 * 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 End

 *

 */

#include <e32base.h>

#include <e32def.h> 

#include <e32cmn.h> 

#include "epos_comasuplasnbase.h"

#include "epos_comasuplasnmessagebase.h"

#include "epos_comasuplend.h"

#include "cstubsuplend.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"

// -----------------------------------------------------------------------------

// CStubSuplEnd::NewL

// Other Items were commented in a header

// -----------------------------------------------------------------------------

//

EXPORT_C CStubSuplEnd* CStubSuplEnd::NewL()

    {

    CStubSuplEnd* self = new (ELeave) CStubSuplEnd;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CStubSuplEnd::ConstructL

// Other Items were commented in a header

// -----------------------------------------------------------------------------

//

void CStubSuplEnd::ConstructL()

    {

    COMASuplEnd::ConstructL();

    //Allocate memory for internal usage....

    }

// -----------------------------------------------------------------------------

// CStubSuplEnd::~CStubSuplEnd

// Other Items were commented in a header

// -----------------------------------------------------------------------------

//

EXPORT_C CStubSuplEnd::~CStubSuplEnd()

    {

    }

// -----------------------------------------------------------------------------

// CStubSuplEnd::EncodeL

// Other Items were commented in a header

// -----------------------------------------------------------------------------

//

HBufC8* CStubSuplEnd::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;

    }

// -----------------------------------------------------------------------------

// CStubSuplEnd::CStubSuplEnd

// Other Items were commented in a header

// -----------------------------------------------------------------------------

//

CStubSuplEnd::CStubSuplEnd()

    {

    }

void CStubSuplEnd::InitializeL()

    {

    if (iPosition)   //This parameter is optional in asn

        {

    InitializePosition();

        }

    }

void CStubSuplEnd::InitializePosition()

    {

    // Retrieve mandatory parameters of Position

    // Retrieve mandatory parameters of Position

    TOMASuplUtcTime utcTime;

    TOMASuplPositionEstimate posEstimate;

    iPosition->GetPosition(utcTime,posEstimate );

    TInt error = 0;

    //Initialize Time

    InitializeTime(utcTime);

    InitializePositionEstimate(posEstimate);

    if(error)

        {

        return;

        }

    else

        {

        COMASuplVelocity* velocity = NULL;

        error = iPosition->GetVelocity(velocity);

        if(error)

            {

            //return 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 CStubSuplEnd::IntializeHorizVelocity(const COMASuplHorizVelocity* aVelocity)

    {

    TUint16 bearing;

    TUint16 horSpeed;

    aVelocity->GetHorizVel(bearing,horSpeed);

    //Initialize bearing,horSpeed

    }

void CStubSuplEnd::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 CStubSuplEnd::IntializeHorizUncertVelocity(const COMASuplHorizVelocity* aVelocity)

    {

    TUint16 bearing;

    TUint16 horSpeed;

    TUint8 uncertSpeed;

    COMASuplHorizUncertVelocity* horizUncertVel = (COMASuplHorizUncertVelocity*)aVelocity;

    horizUncertVel->GetHorizUncertVel(bearing,horSpeed,uncertSpeed);

    //Initialize bearing,horSpeed,uncertSpeed

    }

void CStubSuplEnd::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 CStubSuplEnd::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 CStubSuplEnd::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

        }

    }