/*

* Copyright (c) 2002 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:   This class provides functionality of encoding landmarks

*                both saved and unsaved landmarks (In Landmarks DB).

*

*/

// INCLUDE FILES

#include "CLmkEncodeUnsavedLandmarksOp.h"

#include "CLmkAOOperation.h"

#include <EPos_CPosLmCategoryManager.h>

#include <EPos_CPosLmOperation.h>

#include "CLmkDbUtils.h"

//CONSTANTS

const TReal32 KOperationDone = 1;

// ============================ MEMBER FUNCTIONS ===============================

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

// CLmkEncodeUnsavedLandmarksOp::CLmkEncodeUnsavedLandmarksOp

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CLmkEncodeUnsavedLandmarksOp::CLmkEncodeUnsavedLandmarksOp(

           CPosLandmarkEncoder&  aLandmarkEncoder,

           CPosLandmarkDatabase::TTransferOptions  aTransferOptions)

           :iEncoder(aLandmarkEncoder),

            iTransferOptions(aTransferOptions),

            iCurrentIsLm(ETrue),

            iStatusFlag(KPosLmOperationNotComplete)

    {

    iNrOfSubOperations = 1;

    }

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

// CLmkEncodeUnsavedLandmarksOp::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkEncodeUnsavedLandmarksOp::ConstructL(const RPointerArray<CLmkLandmark>&  aLandmarks)

    {

    for (TInt i = 0; i < aLandmarks.Count(); i++)

        {

        CLmkLandmark* landmark = CLmkLandmark::NewL(*aLandmarks[i]);

        CleanupStack::PushL(landmark);

        User::LeaveIfError(iLandmarks.Append(landmark));

        CleanupStack::Pop();//landmark

        }

    }

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

// CLmkEncodeUnsavedLandmarksOp::NewL

// Two-phased constructor.

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

//

CLmkEncodeUnsavedLandmarksOp* CLmkEncodeUnsavedLandmarksOp::NewL(

                              CPosLandmarkEncoder&  aLandmarkEncoder,

                              const RPointerArray<CLmkLandmark>&  aLandmarks,

                              CPosLandmarkDatabase::TTransferOptions  aTransferOptions )

    {

    CLmkEncodeUnsavedLandmarksOp* self =

        new ( ELeave ) CLmkEncodeUnsavedLandmarksOp(aLandmarkEncoder,

                                                    aTransferOptions);

    CleanupStack::PushL( self );

    self->ConstructL(aLandmarks );

    CleanupStack::Pop();

    return self;

    }

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

// CLmkEncodeUnsavedLandmarksOp::~CLmkEncodeUnsavedLandmarksOp

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

//

CLmkEncodeUnsavedLandmarksOp::~CLmkEncodeUnsavedLandmarksOp()

    {

    iLandmarks.ResetAndDestroy();

    }

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

// CLmkEncodeUnsavedLandmarksOp::NextStep

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

//

void CLmkEncodeUnsavedLandmarksOp::NextStep( TRequestStatus& aStatus,

                                    TReal32& aProgress )

    {

    aStatus = KRequestPending;

    iStatus = &aStatus;

    iProgress = &aProgress;

    TInt err(KErrNone);

    if (iCurrentIsLm)

        {

        CLmkLandmark* lmkLm  = iLandmarks[iCurrentLm++];

        CPosLandmark* lm = lmkLm->PosLandmark();

        TRAP(err,CLmkDbUtils::AddDefaultProtocolL(lm));

        if (iTransferOptions & CPosLandmarkDatabase::EIncludeCategories)

            {

            iCurrentCategory = 0;

            iCategories = lmkLm->Categories();

            if (iCategories.Count() != 0)

                {

                iCurrentIsLm = EFalse;

                }

            }

        TRAP(err,iEncoder.AddLandmarkL(*lm));

        }

    else

        {

        for (TInt i = 0;

            i < iNrOfSubOperations &&

                iCurrentCategory < iCategories.Count(); i++)

            {

            CPosLandmarkCategory* category =iCategories[iCurrentCategory++];

            if (iCurrentCategory == iCategories.Count())

                {

                iCurrentIsLm = ETrue;

                }

            TRAP(err,iEncoder.AddCategoryForLatestLandmarkL(*category));

            }

        }

    if(!err)

        {

        if (iCurrentLm == iLandmarks.Count() &&

            iCurrentCategory == iCategories.Count())

            {

            iStatusFlag = KErrNone;

            aProgress = KOperationDone;

            }

        else if (iCurrentIsLm)

            {

            aProgress = TReal32(iCurrentLm) / iLandmarks.Count();

            }

        else

            {

            aProgress = TReal32(iCurrentLm - 1) / iLandmarks.Count() +

                        TReal32(iCurrentCategory + 1) /

                        (iCategories.Count() + 1) /

                        iLandmarks.Count();

            }

        }

    else

        {

        iStatusFlag = err;

        aProgress = KOperationDone;

        }

    User::RequestComplete( iStatus,iStatusFlag);

    }

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

// CLmkEncodeUnsavedLandmarksOp::ExecuteL

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

//

void CLmkEncodeUnsavedLandmarksOp::ExecuteL()

    {

    // We never use asynchronous methods in synchronous way and therefore

    // don't need to support this method

    User::Leave( KErrNotSupported );

    }

//  End of File