/*

* Copyright (c) 2002-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 importing landmarks to a database.

*

*

*/

#include    <eposlmasyncops.rsg>

#include    <EPos_LandmarksErrors.h>

#include    <EPos_CPosLandmarkParser.h>

#include    <EPos_PosLmImplExtension.h>

#include    <epos_poslmlandmarkhandler.h>

#include    <epos_poslmcategoryhandler.h>

#include    <epos_cposlmglobalcategoryreader.h>

#include    <epos_cposlmdiskutilities.h>

#include    "epos_cposlmlocaldatabase.h"

#include    "epos_cposlmlocaldbaccess.h"

#include    "EPos_LocalLandmarks.h"

#include    "EPos_RPosLmLocalAccessSubsession.h"

#include    "EPos_CPosLmLocalInternalOpActive.h"

#include    "EPos_CPosLmLocalImportOp.h"

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

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

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

//

CPosLmLocalImportOp::CPosLmLocalImportOp(

    CPosLmLocalDatabase& aDb,

    CPosLandmarkParser& aLandmarkParser,

    CPosLandmarkDatabase::TTransferOptions aTransferOptions,

    CPosLmDiskUtilities& aDiskUtils)

:   CPosLmLocalModifyOp(aDb),

    iLandmarkParser(&aLandmarkParser),

    iTransferOptions(aTransferOptions),

    iImportState(EImportParseLm),

    iParserOpStatus(KPosLmOperationNotComplete),

    iDiskUtils(&aDiskUtils)

    {

    iUsesServerData = ETrue; // updates lm name index

    }

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

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

//

void CPosLmLocalImportOp::ConstructL()

    {

    CPosLandmarkDatabase::TTransferOptions invalidOptions =

        iTransferOptions &

        ~CPosLandmarkDatabase::EIncludeCategories &

        ~CPosLandmarkDatabase::EIncludeGlobalCategoryNames &

        ~CPosLandmarkDatabase::ESupressCategoryCreation;

    __ASSERT_ALWAYS(invalidOptions == CPosLandmarkDatabase::EDefaultOptions,

        Panic(KPosLandmarksClientPanic, EPosLmInvalidArgument));

    BaseConstructL();

    ReadInfoFromResourceFileL(R_POS_LM_LOCAL_IMPORT_LMS_OP);

    if (iTransferOptions & CPosLandmarkDatabase::EIncludeCategories)

        {

        iReader = CPosLmGlobalCategoryReader::NewL();

        }

    CPosLmOperation* parserOp = iLandmarkParser->ParseContentL(EFalse);

    CleanupStack::PushL(parserOp);

    iInternalOpActive = CPosLmLocalInternalOpActive::NewL(*this, parserOp);

    CleanupStack::Pop(parserOp); // ownership transferred

    }

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

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

//

void CPosLmLocalImportOp::ConstructL(

    const RArray<TUint>& aLandmarksSelection)

    {

    if (aLandmarksSelection.Count() == 0)

        {

        User::Leave(KErrArgument);

        }

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

        {

        User::LeaveIfError(iSelectedLmIds.Append(aLandmarksSelection[i]));

        }

    iSelectedLmIds.SortUnsigned();

    ConstructL();

    }

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

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

//

CPosLmLocalImportOp* CPosLmLocalImportOp::NewL(

    CPosLmLocalDatabase& aDb,

    CPosLandmarkParser& aLandmarkParser,

    CPosLandmarkDatabase::TTransferOptions aTransferOptions,

    CPosLmDiskUtilities& aDiskUtils)

    {

    CPosLmLocalImportOp* self = new (ELeave)

        CPosLmLocalImportOp(aDb, aLandmarkParser, aTransferOptions, aDiskUtils);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CPosLmLocalImportOp* CPosLmLocalImportOp::NewL(

    CPosLmLocalDatabase& aDb,

    CPosLandmarkParser& aLandmarkParser,

    const RArray<TUint>& aLandmarksSelection,

    CPosLandmarkDatabase::TTransferOptions aTransferOptions,

    CPosLmDiskUtilities& aDiskUtils)

    {

    CPosLmLocalImportOp* self = new (ELeave)

        CPosLmLocalImportOp(aDb, aLandmarkParser, aTransferOptions, aDiskUtils);

    CleanupStack::PushL(self);

    self->ConstructL(aLandmarksSelection);

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CPosLmLocalImportOp::~CPosLmLocalImportOp()

    {

    RollbackAndGenerateEventIfNeeded(Progress());

    delete iReader;

    delete iCurrentLm;

    iCurrentCategoryIds.Close();

    iSelectedLmIds.Close();

    iImportedLmIds.Close();

    delete iInternalOpActive;

    }

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

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

//

void CPosLmLocalImportOp::ImportedLandmarkItemIdsL(

    RArray<TPosLmItemId>& aLmItemIds)

    {

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

        {

        User::LeaveIfError(aLmItemIds.Append(iImportedLmIds[i]));

        }

    }

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

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

//

void CPosLmLocalImportOp::DoNextStepPreL(

    TReal32& aProgress)

    {

    if (iImportState == EImportParseLm)

        {

        ParseLandmarkL();

        // If it is a selected landmark we need to import it to db

        if (IsSelectedLandmark())

            {

            GetParsedLandmarkL();

            if (iTransferOptions & CPosLandmarkDatabase::EIncludeCategories &&

                iCurrentCategoryIds.Count() != 0)

                {

                iImportState = EImportAddLmCatToDb;

                }

            else

                {

                iImportState = EImportAddLmToDb;

                }

            }

        }

    else if (iImportState == EImportAddLmCatToDb)

        {

        ImportLmCategoriesL();

        // Ready importing categories ?

        if (iCurrentCategory == iCurrentCategoryIds.Count())

            {

            iImportState = EImportAddLmToDb;

            }

        }

    else

        {

        // iImportState == EImportAddLmToDb

        ImportLandmarkL();

        // Ready importing landmark

        iImportState = EImportParseLm;

        }

    // Update progress

    UpdateProgress(aProgress);

    }

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

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

//

TBool CPosLmLocalImportOp::DoNextStepPostL(

    TReal32& aProgress)

    {

    // Check if we are ready parsing or not

    if ((iParserOpStatus == KErrNone && iImportState == EImportParseLm) ||

        (IsSelectedLandmarksImported()))

        {

        __ASSERT_ALWAYS(!LandmarkSelection() ||

                        IsSelectedLandmarksImported() ||

                        (LandmarkSelection() &&

                         iSelectedLmIds.Count() > iSelectedLmIdPos &&

                         iCurrentLmIndex > iSelectedLmIds[iSelectedLmIdPos]),

                Panic(KPosLandmarksClientPanic, EPosInvalidIndex));

        User::LeaveIfError(GenerateEventIfNeeded(aProgress));

        iStatusFlag = KErrNone;

        return EFalse;

        }

    return ETrue;

    }

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

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

//

TReal32 CPosLmLocalImportOp::Step()

    {

    return iCurrentProgress - iLastReportedProgress;

    }

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

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

//

void CPosLmLocalImportOp::CheckResourceValue(

    TInt /*aResourceId*/,

    TInt aNoOfSubOperations)

    {

    __ASSERT_ALWAYS(aNoOfSubOperations > 0, Panic(KPosLandmarksClientPanic,

        EPosInvalidValueSpecifiedInResourceFile));

    }

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

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

//

void CPosLmLocalImportOp::HandleError(

    TInt& aError)

    {

    iStatusFlag = aError;

    RollbackAndGenerateEventIfNeeded(Progress());

    }

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

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

//

void CPosLmLocalImportOp::InternalOpCompleted(

    TInt aStatus,

    TReal32 aProgress,

    TRequestStatus& aClientStatus,

    TReal32& aClientProgress)

    {

    iParserOpStatus = aStatus;

    iParserProgress = aProgress;

    if (aStatus == KErrNone || aStatus == KPosLmOperationNotComplete)

        {

        // Internal operation did not fail. Even if parser operation completed

        // with KErrNone, this operation is not done; the landmark must be

        // imported as well.

        TRAP(aStatus, DoNextStepPreL(aClientProgress));

        if (aStatus == KErrNone)

            {

            // Status must be changed to KPosLmOperationNotComplete. Otherwise,

            // the client thinks that the operation is done.

            aStatus = KPosLmOperationNotComplete;

            }

        else

            {

            RollbackAndGenerateEventIfNeeded(aProgress);

            }

        }

    else

        {

        RollbackAndGenerateEventIfNeeded(aProgress);

        }

    TRequestStatus* clientStatus = &aClientStatus;

    User::RequestComplete(clientStatus, aStatus);

    }

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

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

//

void CPosLmLocalImportOp::DoNextStep(

    TRequestStatus& aStatus,

    TReal32& aProgress)

    {

    if (IsInParsingState())

        {

        // Performs next step on parser operation with active object.

        aStatus = KRequestPending;

        PrepareNextParsingStep();

        iInternalOpActive->DoNext(aStatus, aProgress);

        }

    else

        {

        // Import landmark or categories. May also be in compacting state.

        NextStep(aStatus, aProgress);

        }

    }

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

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

//

void CPosLmLocalImportOp::DoExecuteL()

    {

    TRequestStatus status(KPosLmOperationNotComplete);

    TRequestStatus statusInternalOp;

    TReal32 progress;

    do

        {

        if (IsInParsingState())

            {

            // Performs next step on parser operation without active object.

            // Using an active object would hang the thread when calling

            // User::WaitForRequest.

            PrepareNextParsingStep();

            iInternalOpActive->InternalOpNextStep(statusInternalOp, progress);

            User::WaitForRequest(statusInternalOp);

            User::LeaveIfError(statusInternalOp.Int());

            // To finish a parsing next step, this function must be called.

            // The function would have been called by the active object if

            // running asynchronously (DoNextStep).

            InternalOpCompleted(statusInternalOp.Int(), progress, status,

                progress);

            }

        else

            {

            // Import landmark or categories. May also be in compacting state.

            NextStep(status, progress);

            }

        User::WaitForRequest(status);

        User::LeaveIfError(status.Int());

        } while (status.Int() == KPosLmOperationNotComplete);

    }

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

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

//

void CPosLmLocalImportOp::ParseLandmarkL()

    {

    // A landmark has previously been parsed when this function is called.

    // Error during parsing of landmarks

    if (iParserOpStatus != KErrNone &&

        iParserOpStatus != KPosLmOperationNotComplete)

        {

        User::Leave(iParserOpStatus);

        }

    // Reset landmark and landmark category

    delete iCurrentLm;

    iCurrentLm = NULL;

    iCurrentCategoryIds.Reset();

    }

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

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

//

void CPosLmLocalImportOp::GetParsedLandmarkL()

    {

    // Get landmark and landmark category ids

    iCurrentLm = iLandmarkParser->LandmarkLC();

    CleanupStack::Pop();

    iCurrentLm->GetCategoriesL(iCurrentCategoryIds);

    // Reset category ids in landmark

    iCurrentLm->RemoveLandmarkAttributes(CPosLandmark::ECategoryInfo);

    }

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

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

//

void CPosLmLocalImportOp::ImportLandmarkL()

    {

    iDiskUtils->DiskSpaceBelowCriticalLevelL(

        iDiskUtils->EstimatedDiskSizeOfLmOperation(

        CPosLmDiskUtilities::EAddLandmarkOp,

        *iCurrentLm ), iDb->DatabaseDrive() );

    // Add landmark to db

    PosLmLandmarkHandler::AddLandmarkL( *iDb->DatabaseAccess(), *iCurrentLm );

    iDb->NameIndex().AddL( *iCurrentLm );

    // Add lm item id to array of imported lm item ids

    User::LeaveIfError( iImportedLmIds.Append( iCurrentLm->LandmarkId() ) );

    // Imported a selected landmark, so point to next id in array

    iSelectedLmIdPos++;

    iCurrentCategory = 0;

    }

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

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

//

void CPosLmLocalImportOp::ImportLmCategoriesL()

    {

    for (TInt i = 0;

        i < iNoOfSubOperations &&

        iCurrentCategory < iCurrentCategoryIds.Count();

        i++)

        {

        // Get next gategory

        CPosLandmarkCategory* lmcat =

            iLandmarkParser->LandmarkCategoryLC(

            iCurrentCategoryIds[iCurrentCategory++]);

        TPosLmItemId dbItemId;

        TBool lmCatInDb = ETrue;

        // Is global category ?

        if (lmcat->GlobalCategory() != KPosLmNullGlobalCategory)

            {

            TBool dummyBool;

            // Is global category in db ?

            if (PosLmCategoryHandler::IsGlobalCategoryExistingL(

                    *iDb->DatabaseAccess(), lmcat->GlobalCategory(),

                    dbItemId, dummyBool))

                {

                // Set category id for global category

                PosLmImplExtension::SetCategoryIdL(*lmcat, dbItemId);

                // Import global category names ?

                if (iTransferOptions &

                    CPosLandmarkDatabase::EIncludeGlobalCategoryNames)

                    {

                    // Update global category name in db

                    TPtrC categoryName;

                    TInt err = lmcat->GetCategoryName(categoryName);

                    if (err == KErrNone)

                        {

                        PosLmCategoryHandler::UpdateGlobalCategoryNameL(

                            *iDb->DatabaseAccess(), *lmcat);

                        iLastChangedCategoryId = lmcat->CategoryId();

                        iNrOfCategoriesUpdated++;

                        }

                    }

                }

            else

                {

                // Is global category in resource ?

                HBufC* categoryNameFromResource =

                    GlobalCategoryNameInResourceL(lmcat);

                CleanupStack::PushL(categoryNameFromResource);

                if (categoryNameFromResource)

                    {

                    // Import global category names ?

                    if (iTransferOptions &

                        CPosLandmarkDatabase::EIncludeGlobalCategoryNames)

                        {

                        // Add global category to db with imported name

                        lmCatInDb = AddCategoryL(*lmcat);

                        }

                    else

                        {

                        // Add global category to db with name from resource

                        lmcat->SetCategoryNameL(

                            categoryNameFromResource->Des());

                        lmCatInDb = AddCategoryL(*lmcat);

                        }

                    }

                else

                    {

                    // Global category neither in db or resource file

                    lmCatInDb = AddLocalCategoryL(*lmcat, dbItemId);

                    }

                CleanupStack::PopAndDestroy(categoryNameFromResource);

                }

            }

        else

            {

            // Not a global category

            lmCatInDb = AddLocalCategoryL(*lmcat, dbItemId);

            }

        if (lmCatInDb)

            {

            // Add category id to landmark

            iCurrentLm->AddCategoryL(lmcat->CategoryId());

            }

        CleanupStack::PopAndDestroy(lmcat);

        }

    }

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

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

//

TBool CPosLmLocalImportOp::AddLocalCategoryL(

    CPosLandmarkCategory& aLmCat,

    TPosLmItemId& aLmItemId)

    {

    // Set category id for category

    PosLmImplExtension::SetGlobalCategory(aLmCat, KPosLmNullGlobalCategory);