/*

 * 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: SuplPos

 *

 */

#include <e32base.h>

#include <e32def.h> 

#include <e32cmn.h> 

#include "epos_comasuplasnbase.h"

#include "epos_comasuplasnmessagebase.h"

#include "epos_comasuplposinit.h"

#include "epos_comasuplpos.h"

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

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

// CStubSuplPos::NewL

// Other Items were commented in a header

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

//

EXPORT_C CStubSuplPos* CStubSuplPos::NewL()

    {

    CStubSuplPos* self = new (ELeave) CStubSuplPos;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CStubSuplPos::~CStubSuplPos

// Other Items were commented in a header

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

//

EXPORT_C CStubSuplPos::~CStubSuplPos()

    {

    }

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

// CStubSuplPos::ConstructL

// Other Items were commented in a header

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

//

void CStubSuplPos::ConstructL()

    {

    COMASuplPos::ConstructL();

    //Allocate memory for internal usage....

    }

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

// CStubSuplPos::EncodeL

// Other Items were commented in a header

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

//

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

    }

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

// CStubSuplPos::CStubSuplPos

// Other Items were commented in a header

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

//

CStubSuplPos::CStubSuplPos()

    {

    }

void CStubSuplPos::InitializeL()

    {

    //Initialize your library

    if(iPayload)

        {

        HBufC8* payloadData = NULL;

        COMASuplPosPayload::TOMASuplPosPayloadType payloadType;

        iPayload->GetPosPayload(payloadData,payloadType);

        if(!payloadData)  

            {

            //error   

            }           

        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:

                {

                }           

            }

        }

    else

        {   

        //error

        }

    if(iOptionalMask & (1<<(0))) //means velocity has been set

        {

        TOMASuplVelocityType velocityType = iVelocity->VelType();

        COMASuplHorizVelocity* horizVelocity = iVelocity->Velocity();

        if(horizVelocity)

            {

            switch(velocityType)

                {

                case EHorizVelocity:

                    {

                    //Initialize

                    IntializeHorizVelocity(horizVelocity);

                    break;      

                    }

                case EHorizAndVertVelocity:

                    {

                    //Initialize

                    IntializeHorizAndVertVelocity(horizVelocity);

                    break;

                    }

                case EHorizUncertVelocity:

                    {

                    //Initialize

                    IntializeHorizUncertVelocity(horizVelocity);

                    break;

                    }

                case EHorizAndVertUncertVelocity:

                    {

                    //Initialize

                    IntializeHorizVertUncertVelocity(horizVelocity);

                    break;  

                    }

                default:

                    {

                    //error

                    }

                }       

            }

        else

            {

            //error

            }

        }

    else

        {

        //return error

        }

    }

void CStubSuplPos::IntializeHorizVelocity(const COMASuplHorizVelocity* aVelocity)

    {

    TUint16 bearing;

    TUint16 horSpeed;

    aVelocity->GetHorizVel(bearing,horSpeed);

    //Initialize bearing,horSpeed

    }

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

    {

    TUint16 bearing;

    TUint16 horSpeed;

    TUint8 uncertSpeed;

    COMASuplHorizUncertVelocity* horizUncertVel = (COMASuplHorizUncertVelocity*)aVelocity;

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

    //Initialize bearing,horSpeed,uncertSpeed

    }

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

    }