/*
* Copyright (c) 2005 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: Operation for exporting landmarks from a database.
*
*
*/


// INCLUDE FILES
#include    <epos_cposlmresourcereader.h>
#include    <eposlmasyncops.rsg>
#include    <EPos_CPosLandmarkEncoder.h>
#include    <EPos_LandmarksErrors.h>
#include    <EPos_PosLmImplExtension.h>
#include    <epos_poslmlandmarkhandler.h>
#include    <epos_poslmcategoryhandler.h>
#include    <epos_cposlmglobalcategoryreader.h>
#include    "EPos_CPosLmLocalExportOp.h"
#include    "epos_cposlmlocaldatabase.h"
#include    "epos_cposlmlocaldbaccess.h"
#include    "EPos_LocalLandmarks.h"

//CONSTANTS
const TReal32 KOperationDone = 1;

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

// -----------------------------------------------------------------------------
// CPosLmLocalExportOp::CPosLmLocalExportOp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPosLmLocalExportOp::CPosLmLocalExportOp(
    CPosLmLocalDatabase& aDb,
    CPosLandmarkEncoder& aLandmarkEncoder,
    CPosLandmarkDatabase::TTransferOptions aTransferOptions)
:   CPosLmLocalOperation(aDb),
    iLandmarkEncoder(&aLandmarkEncoder),
    iTransferOptions(aTransferOptions),
    iStatusFlag(KPosLmOperationNotComplete),
    iCurrentIsLm(ETrue),
    iNrOfSubOperations(1)
    {
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportOp::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPosLmLocalExportOp::ConstructL(
    const RArray<TPosLmItemId>& aLandmarkIdArray)
    {
    CPosLandmarkDatabase::TTransferOptions invalidOptions =
        iTransferOptions &
        ~CPosLandmarkDatabase::EIncludeCategories &
        ~CPosLandmarkDatabase::EIncludeGlobalCategoryNames;

    __ASSERT_ALWAYS(invalidOptions == CPosLandmarkDatabase::EDefaultOptions,
        Panic(KPosLandmarksClientPanic, EPosLmInvalidArgument));

    BaseConstructL();

    if (aLandmarkIdArray.Count() == 0)
        {
        User::Leave(KErrArgument);
        }

    if ((iTransferOptions & CPosLandmarkDatabase::EIncludeCategories) &&
        (iTransferOptions & CPosLandmarkDatabase::EIncludeGlobalCategoryNames))
        {
        iReader = CPosLmGlobalCategoryReader::NewL();
        }

    for (TInt i = 0; i < aLandmarkIdArray.Count(); i++)
        {
        User::LeaveIfError(iLandmarkIdArray.Append(aLandmarkIdArray[i]));
        }

    ReadInfoFromResourceFileL();

    AquireLockL(CPosLmLocalDatabase::EReadLock);
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportOp::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPosLmLocalExportOp* CPosLmLocalExportOp::NewL(
    CPosLmLocalDatabase& aDb,
    CPosLandmarkEncoder& aLandmarkEncoder,
    const RArray<TPosLmItemId>& aLandmarkIdArray,
    CPosLandmarkDatabase::TTransferOptions aTransferOptions)
    {
    CPosLmLocalExportOp* self = new (ELeave)
        CPosLmLocalExportOp(aDb, aLandmarkEncoder, aTransferOptions);
    CleanupStack::PushL(self);
    self->ConstructL(aLandmarkIdArray);
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
CPosLmLocalExportOp::~CPosLmLocalExportOp()
    {
    delete iReader;
    iLandmarkIdArray.Close();
    iCategoryIdArray.Close();
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportOp::NextStepL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CPosLmLocalExportOp::NextStepL(
    TReal32& aProgress)
    {
    if (iCurrentIsLm)
        {
        CPosLandmark* lm = ReadLmFromDbLC(iLandmarkIdArray[iCurrentLm++]);
        iLandmarkEncoder->AddLandmarkL(*lm);

        if (iTransferOptions & CPosLandmarkDatabase::EIncludeCategories)
            {
            iCategoryIdArray.Close();
            iCurrentCategory = 0;

            lm->GetCategoriesL(iCategoryIdArray);
            if (iCategoryIdArray.Count() != 0)
                {
                iCurrentIsLm = EFalse;
                }
            }

        CleanupStack::PopAndDestroy(lm);
        }
    else
        {
        for (TInt i = 0;
            i < iNrOfSubOperations &&
                iCurrentCategory < iCategoryIdArray.Count(); i++)
            {
            	//coverity[alloc_fn : FALSE]
            	//coverity[assign :FALSE]
            CPosLandmarkCategory* category =
                ReadCategoryFromDbLC(iCategoryIdArray[iCurrentCategory++]);

            if (iTransferOptions &
                CPosLandmarkDatabase::EIncludeGlobalCategoryNames)
                {
                	//coverity[leave_without_push : FALSE]
                SetPredefinedGlobalNameL(category);
                }

            iLandmarkEncoder->AddCategoryForLatestLandmarkL(*category);

            CleanupStack::PopAndDestroy(category);

            if (iCurrentCategory == iCategoryIdArray.Count())
                {
                iCurrentIsLm = ETrue;
                }
            }
        }

    if (iCurrentLm == iLandmarkIdArray.Count() &&
        iCurrentCategory == iCategoryIdArray.Count())
        {
        iStatusFlag = KErrNone;
        aProgress = KOperationDone;
        ReleaseLock();
        }
    else if (iCurrentIsLm)
        {
        aProgress = TReal32(iCurrentLm) / iLandmarkIdArray.Count();
        }
    else
        {
        aProgress = TReal32(iCurrentLm - 1) / iLandmarkIdArray.Count() +
                    TReal32(iCurrentCategory + 1) /
                    (iCategoryIdArray.Count() + 1) /
                    iLandmarkIdArray.Count();
        }

    return iStatusFlag;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportOp::HandleError
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalExportOp::HandleError(
    TInt& aError)
    {
    iStatusFlag = aError;
    ReleaseLock();
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportLandmarksOp::ReadLmFromDbLC
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLandmark* CPosLmLocalExportOp::ReadLmFromDbLC(TPosLmItemId aId)
    {
    CPosLandmark* landmark = CPosLandmark::NewLC();
    PosLmImplExtension::SetLandmarkIdL(*landmark, aId);

    PosLmLandmarkHandler::ReadLandmarkL(*iDb->DatabaseAccess(), *landmark);
    return landmark;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportLandmarksOp::ReadCategoryFromDbLC
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLandmarkCategory* CPosLmLocalExportOp::ReadCategoryFromDbLC(
    TPosLmItemId aId)
    {
    CPosLandmarkCategory* category = CPosLandmarkCategory::NewLC();
    PosLmImplExtension::SetCategoryIdL(*category, aId);

    PosLmCategoryHandler::ReadCategoryL(*iDb->DatabaseAccess(), *category);
    return category;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportLandmarksOp::SetPredefinedGlobalNameL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalExportOp::SetPredefinedGlobalNameL(
    CPosLandmarkCategory* aCategory)
    {
    TPosLmGlobalCategory globalCat = aCategory->GlobalCategory();
    if (globalCat != KPosLmNullGlobalCategory)
        {
        TBool catFound = EFalse;
        for (TInt i = 0; i < iReader->Count() && !catFound; i++)
            {
            CPosLandmarkCategory* readerCategory = iReader->GlobalCategoryLC(i);

            TPtrC catName;
            if (readerCategory->GlobalCategory() == globalCat &&
                readerCategory->GetCategoryName(catName) == KErrNone)
                {
                catFound = ETrue;
                aCategory->SetCategoryNameL(catName);
                }

            CleanupStack::PopAndDestroy(readerCategory);
            }
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalExportLandmarksOp::ReadInfoFromResourceFileL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalExportOp::ReadInfoFromResourceFileL()
    {
    CPosLmResourceReader* resources =
        CPosLmResourceReader::NewLC(KPosLocalSuboperationResourceFile);

    iNrOfSubOperations = resources->ReadInt32L(R_POS_LM_LOCAL_EXPORT_LMS_OP);

    if (iNrOfSubOperations <= 0)
        {
        Panic(KPosLandmarksClientPanic,
            EPosInvalidValueSpecifiedInResourceFile);
        }

    CleanupStack::PopAndDestroy(resources);
    }

//  End of File