/*

* 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 removing landmarks from a database.

*

*

*/

#include    <epos_cposlmresourcereader.h>

#include    <eposlmasyncops.rsg>

#include    <EPos_LandmarksErrors.h>

#include    <epos_cposlmdiskutilities.h>

#include    <epos_cposlmlocaldbaccess.h>

#include    <epos_poslmlandmarkhandler.h>

#include    "epos_cposlmlocaldatabase.h"

#include    "EPos_LocalLandmarks.h"

#include    "EPos_CPosLmLocalLandmarkIterator.h"

#include    "epos_rposlmlocalnameindex.h"

#include    "EPos_RPosLmLocalAccessSubsession.h"

#include    "EPos_CPosLmLocalRemoveLandmarksOp.h"

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

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

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

//

CPosLmLocalRemoveLandmarksOp::CPosLmLocalRemoveLandmarksOp( CPosLmLocalDatabase& aDb ) :

    CPosLmLocalModifyOp(aDb)

    {

    iUsesServerData = ETrue;

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::ConstructL(

    const RArray<TPosLmItemId>& aLandmarkIdArray,

    TInt aResourceId )

    {

    if ( aLandmarkIdArray.Count() == 0 )

        {

        User::Leave( KErrArgument );

        }

    BaseConstructL();

    ReadInfoFromResourceFileL( aResourceId );

    iLandmarkIdArray.ReserveL( aLandmarkIdArray.Count() ); // to avoid heap fragmentation

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

        {

        }

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::ConstructL()

    {

    BaseConstructL();

    CPosLmItemIterator* iterator =

        CPosLmLocalLandmarkIterator::NewL( *iDb, ETrue );

    CleanupStack::PushL( iterator );

    if ( iterator->NumOfItemsL() > 0 )

        {

        iterator->GetItemIdsL( iLandmarkIdArray, 0, iterator->NumOfItemsL() );

        }

    CleanupStack::PopAndDestroy( iterator );

    if ( iLandmarkIdArray.Count() > 0 )

        {

        // Check disk space

        CPosLmDiskUtilities* diskutil = CPosLmDiskUtilities::NewL();

        CleanupStack::PushL(diskutil);

        diskutil->DiskSpaceBelowCriticalLevelL(

            diskutil->EstimatedDiskSizeOfLmOperation(

                CPosLmDiskUtilities::ERemoveLandmarksOp,

                iLandmarkIdArray), iDb->DatabaseDrive());

        CleanupStack::PopAndDestroy(diskutil);

        ReadInfoFromResourceFileL( R_POS_LM_LOCAL_REMOVE_ALL_LMS_OP );

        }

    }

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

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

//

CPosLmLocalRemoveLandmarksOp* CPosLmLocalRemoveLandmarksOp::NewL(

    CPosLmLocalDatabase& aDb,

    const RArray<TPosLmItemId>& aLandmarkIdArray)

    {

    CPosLmLocalRemoveLandmarksOp* self = new (ELeave)

        CPosLmLocalRemoveLandmarksOp(aDb);

    CleanupStack::PushL(self);

    self->ConstructL(aLandmarkIdArray, R_POS_LM_LOCAL_REMOVE_LMS_OP);

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CPosLmLocalRemoveLandmarksOp* CPosLmLocalRemoveLandmarksOp::NewL(

    CPosLmLocalDatabase& aDb)

    {

    CPosLmLocalRemoveLandmarksOp* self = new (ELeave)

        CPosLmLocalRemoveLandmarksOp(aDb);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CPosLmLocalRemoveLandmarksOp::~CPosLmLocalRemoveLandmarksOp()

    {

    RollbackAndGenerateEventIfNeeded(Progress());

    iLandmarkIdArray.Close();

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::DoNextStepPreL(

    TReal32& aProgress)

    {

    if ( iLandmarkIdArray.Count() == 0 )

        {

        aProgress = 1;

        }

    else

        {

        RArray<TPosLmItemId> removed;

        CleanupClosePushL( removed );

        for (TInt i = 0; i < iNoOfSubOperations &&

            iCurrent < iLandmarkIdArray.Count(); i++)

            {

            PosLmLandmarkHandler::RemoveLandmarkL(

                *iDb->DatabaseAccess(), iLandmarkIdArray[iCurrent] );

            removed.AppendL( iLandmarkIdArray[iCurrent] );

            iCurrent++;

            }

        iDb->NameIndex().RemoveL( removed );

        CleanupStack::PopAndDestroy( &removed );

        // Set progress

        aProgress = TReal32(iCurrent)/iLandmarkIdArray.Count();

        }

    }

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

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

//

TBool CPosLmLocalRemoveLandmarksOp::DoNextStepPostL(

    TReal32& aProgress)

    {

    if (iCurrent < iLandmarkIdArray.Count())

        {

        return ETrue;

        }

    User::LeaveIfError(GenerateEventIfNeeded(aProgress));

    iStatusFlag = KErrNone;

    return EFalse;

    }

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

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

//

TReal32 CPosLmLocalRemoveLandmarksOp::Step()

    {

    if (iLandmarkIdArray.Count() == 0)

        {

        return 1.0f;

        }

    return 1.0f/iLandmarkIdArray.Count();

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::CheckResourceValue(

    TInt /*aResourceId*/,

    TInt aNoOfSubOperations)

    {

    __ASSERT_ALWAYS(aNoOfSubOperations > 0, Panic(KPosLandmarksClientPanic,

        EPosInvalidValueSpecifiedInResourceFile));

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::HandleError(

    TInt& aError)

    {

    iStatusFlag = aError;

    RollbackAndGenerateEventIfNeeded(Progress());

    }

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

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

//

void CPosLmLocalRemoveLandmarksOp::RollbackAndGenerateEventIfNeeded(

    TReal32 aProgress)

    {

    RollbackIfNeeded();

    GenerateEventIfNeeded(aProgress);

    // Reset flag: rollback and event generation should not be done twice.

    iStatusFlag = KErrNone;

    }

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

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

//

TInt CPosLmLocalRemoveLandmarksOp::GenerateEventIfNeeded(

    TReal32 aProgress)

    {

    if (iStatusFlag != KErrNone && aProgress > 0)

        {

        // If only one landmark has been removed, a more specific event can be

        // reported.

        if (iCurrent == 1)

            {

            return iDb->RegisterEvent(EPosLmEventLandmarkDeleted,

                iLandmarkIdArray[0]);

            }

        // If more than one landmark have been removed, a general event is

        // reported.

        if (iCurrent > 0)

            {

            return iDb->RegisterEvent(EPosLmEventLandmarkUnknownChanges);

            }

        }

    // Nothing has happend, don't report event.

    return KErrNone;

    }