/*

* Copyright (c) 2002-2007 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: Handle to a local landmark database.

*

*

*/

#include    <EPos_CPosLandmark.h>

#include    <EPos_PosLmImplExtension.h>

#include    <EPos_CPosLmOperation.h>

#include    <epos_cposlmlocaldbaccess.h>

#include    <epos_poslmlandmarkhandler.h>

#include    <epos_poslmcategoryhandler.h>

#include    <epos_poslmdatabaseutility.h>

#include    <epos_cposlmdiskutilities.h>

#include    <epos_cposlmsettingshandler.h>

#include    <epos_rposlandmarkserver.h>

#include    <EPos_LandmarksUids.hrh>

#include    "EPos_CPosLmLocalLandmarkIterator.h"

#include    "EPos_CPosLmLocalRemoveLandmarksOp.h"

#include    "EPos_CPosLmPartialReadParameters.h"

#include    "EPos_CPosLmLocalReadPartialLmOp.h"

#include    "EPos_CPosLmLocalInitializeOp.h"

#include    "EPos_CPosLmLocalCompactingOp.h"

#include    "EPos_CPosLmLocalExportOp.h"

#include    "EPos_CPosLmLocalImportOp.h"

#include    "EPos_CPosLmLocalImportedLmIterator.h"

#include    "EPos_CPosLmLocalInternalProxyOp.h"

#include    "epos_rposlmlocalnameindex.h"

#include    "EPos_RPosLmLocalAccessSubsession.h"

#include    "EPos_CPosLmLocalCategoryManager.h"

#include    "epos_cposlmlocaldbfastcounters.h"

#include    "epos_cposlmlocaldatabase.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// LmDbReleaseReadLock Releases a db lock for the CPosLmLocalDatabase. This

// function can be used as a TCleanupItem.

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

//

void LmDbReleaseReadLock( TAny* aLocalDatabase )

    {

    reinterpret_cast<CPosLmLocalDatabase*>( aLocalDatabase )->

        ReleaseLock( CPosLmLocalDatabase::EReadLock );

    }

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

// LmDbReleaseWriteLock Releases a db lock for the CPosLmLocalDatabase. This

// function can be used as a TCleanupItem.

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

//

void LmDbReleaseWriteLock( TAny* aLocalDatabase )

    {

    reinterpret_cast<CPosLmLocalDatabase*>( aLocalDatabase )->

        ReleaseLock( CPosLmLocalDatabase::EWriteLock );

    }

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

// LmDbRollbackServerTransaction Rollbacks a transaction for the server data. 

// This function can be used as a TCleanupItem.

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

//

void LmDbRollbackServerTransaction( TAny* aLmLocalDatabase )

    {

    reinterpret_cast<CPosLmLocalDatabase*>( aLmLocalDatabase )->

        RollbackServerTransaction();

    }

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

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

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

//

CPosLmLocalDatabase::CPosLmLocalDatabase()

    {

    }

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

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

//

void CPosLmLocalDatabase::ConstructL(

    TAny* aDatabaseUri)

    {

    iPartialSettings = CPosLmPartialReadParameters::NewLC();

    CleanupStack::Pop(iPartialSettings);

    iDiskUtilities = CPosLmDiskUtilities::NewL();

    iDbAccess = CPosLmLocalDbAccess::NewL();

    iServer = new (ELeave) RPosLandmarkServer;

    User::LeaveIfError(iServer->Connect());

    iSubSession = new (ELeave) RPosLmLocalAccessSubsession;

    User::LeaveIfError(iSubSession->Open(*iServer));

    if (aDatabaseUri)

        {

        iDbUri = PosLmDatabaseUtility::CreateDatabaseUriL(

            *static_cast<HBufC*> (aDatabaseUri));

        OpenDatabaseL(EFalse);

        }

    else

        {

        CPosLmSettingsHandler* handler = CPosLmSettingsHandler::NewL();

        CleanupStack::PushL(handler);

        iDbUri = handler->GetDefaultDatabaseUriL();

        CleanupStack::PopAndDestroy(handler);

        OpenDatabaseL(ETrue);

        }

    iNameIndex = new (ELeave) RPosLmLocalNameIndex( *iSubSession );

    User::LeaveIfError( iNameIndex->Open() );

    iCategoryManager = CPosLmLocalCategoryManager::NewL( this );

    iFastCounters = CPosLmLocalDbFastCounters::NewL( *iDbAccess );

    }

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

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

//

EXPORT_C CPosLmLocalDatabase* CPosLmLocalDatabase::OpenL(

    TAny* aDatabaseUri)

    {

    CPosLmLocalDatabase* self = new( ELeave ) CPosLmLocalDatabase;

    CleanupStack::PushL(self);

    self->ConstructL(aDatabaseUri);

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

EXPORT_C CPosLmLocalDatabase::~CPosLmLocalDatabase()

    {

    delete iFastCounters;

    delete iCategoryManager;

    if ( iNameIndex )

        {

        iNameIndex->Close();

        delete iNameIndex;

        }

    delete iDbAccess;

    if (iSubSession)

        {

        iSubSession->Close();

        delete iSubSession;

        }

    if (iServer)

        {

        iServer->Close();

        delete iServer;

        }

    delete iDiskUtilities;

    delete iDbUri;

    delete iPartialSettings;

    }

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

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

//

void CPosLmLocalDatabase::CopyPartialSettingsL(

    const CPosLmPartialReadParameters& aFromSetting,

    CPosLmPartialReadParameters& aToSetting)

    {

    RArray<TUint> requestedFields;

    CleanupClosePushL(requestedFields);

    aToSetting.SetRequestedAttributes(aFromSetting.RequestedAttributes());

    User::LeaveIfError(

        aFromSetting.GetRequestedPositionFields(requestedFields));

    User::LeaveIfError(aToSetting.SetRequestedPositionFields(requestedFields));

    CleanupStack::PopAndDestroy(&requestedFields);

    }

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

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

//

EXPORT_C CPosLmLocalDbAccess* CPosLmLocalDatabase::DatabaseAccess()

    {

    return iDbAccess;

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::LeaveIfInitializingIsNeededL()

    {

    if (IsInitializingNeeded())

        {

        if (iDbAccess->IsDamaged())

            {

            User::Leave(KErrCorrupt);

            }

        else 

            {

            User::Leave(KErrPosLmNotInitialized);

            }

        }

    }

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

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

//

TChar CPosLmLocalDatabase::DatabaseDrive()

    {

    return iDbDrive;

    }

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

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

//

RPosLmLocalAccessSubsession& CPosLmLocalDatabase::Session()

    {

    return *iSubSession;

    }

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

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

//

EXPORT_C RPosLmLocalNameIndex& CPosLmLocalDatabase::NameIndex()

    {

    return *iNameIndex;

    }

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

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

//

EXPORT_C const RPosLmLocalNameIndex& CPosLmLocalDatabase::NameIndex() const

    {

    return *iNameIndex;

    }

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

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

//

TInt CPosLmLocalDatabase::RegisterEvent(

    TPosLmEventType aEventType,

    TPosLmItemId aId)

    {

    return iSubSession->ReportEvent(aEventType, aId);

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::AquireLockLC( TLockType aLockType )

    {

    AquireLockL( aLockType );

    if (aLockType == EReadLock)

        {

        CleanupStack::PushL(TCleanupItem(*LmDbReleaseReadLock, this));

        }

    else

        {

        CleanupStack::PushL(TCleanupItem(*LmDbReleaseWriteLock, this));

        }

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::AquireLockL( TLockType aLockType )

    {

    User::LeaveIfError( iSubSession->SetDatabaseLock( aLockType ) );

    }

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

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

//

EXPORT_C TInt CPosLmLocalDatabase::ReleaseLock( TLockType aLockType )

    {

    return iSubSession->ReleaseDatabaseLock( aLockType );

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::BeginServerTransactionL()

    {

    User::LeaveIfError( NameIndex().BeginTransaction() );

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::BeginServerTransactionLC()

    {

    BeginServerTransactionL();

    CleanupStack::PushL (TCleanupItem( *LmDbRollbackServerTransaction, this ) );

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::CommitServerTransactionL()

    {

    User::LeaveIfError( NameIndex().CommitTransaction() );

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::CommitServerTransactionLX()

    {

    CommitServerTransactionL();

    CleanupStack::Pop(); // rollback

    }

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

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

//

EXPORT_C void CPosLmLocalDatabase::RollbackServerTransaction()

    {

    NameIndex().RollbackTransaction();

    }

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

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

//

TBool CPosLmLocalDatabase::IsInitializingNeeded() const

    {

    if ( iDbAccess->InitFlag() != ENoInit || 

         iDbAccess->IsDamaged() || 

         NameIndex().Status() != KErrNone )

        {

        return ETrue;

        }

    return EFalse;

    }

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

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

//

CPosLmOperation* CPosLmLocalDatabase::InitializeL()

    {

    return CPosLmLocalInitializeOp::NewL(*this);

    }

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

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

//

CPosLandmark* CPosLmLocalDatabase::ReadLandmarkLC(

    TPosLmItemId aLandmarkId)

    {

    return ReadLmLC(aLandmarkId, EFalse);

    }

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

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

//

CPosLmItemIterator* CPosLmLocalDatabase::LandmarkIteratorL()

    {

    LeaveIfInitializingIsNeededL();

    return CPosLmLocalLandmarkIterator::NewL(*this);

    }

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

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

//

CPosLmItemIterator* CPosLmLocalDatabase::LandmarkIteratorL(

    const TPosLmSortPref& aSortPref)

    {

    LeaveIfInitializingIsNeededL();

    return CPosLmLocalLandmarkIterator::NewL(*this, aSortPref);

    }

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

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

//

TPosLmItemId CPosLmLocalDatabase::AddLandmarkL( CPosLandmark& aLandmark )

    {

    LeaveIfInitializingIsNeededL();

    iDiskUtilities->DiskSpaceBelowCriticalLevelL(

        iDiskUtilities->EstimatedDiskSizeOfLmOperation(

        CPosLmDiskUtilities::EAddLandmarkOp,

        aLandmark ), iDbDrive );

    AquireLockLC( EWriteLock );

    BeginServerTransactionLC();

    iDbAccess->BeginTransactionLC();

    PosLmLandmarkHandler::AddLandmarkL( *iDbAccess, aLandmark );

    NameIndex().AddL( aLandmark );

    iDbAccess->CommitTransactionAndPopL();

    CommitServerTransactionLX();

    CleanupStack::PopAndDestroy(); // DbLock

    User::LeaveIfError(

        RegisterEvent( EPosLmEventLandmarkCreated, aLandmark.LandmarkId() ) );

    return aLandmark.LandmarkId();

    }

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

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

//

void CPosLmLocalDatabase::UpdateLandmarkL( const CPosLandmark& aLandmark )

    {

    LeaveIfInitializingIsNeededL();

    if ( aLandmark.IsPartial() )

        {

        User::Leave( KErrArgument );

        }

    iDiskUtilities->DiskSpaceBelowCriticalLevelL(

        iDiskUtilities->EstimatedDiskSizeOfLmOperation(

        CPosLmDiskUtilities::EUpdateLandmarkOp,

        aLandmark ), iDbDrive );

    AquireLockLC( EWriteLock );

    BeginServerTransactionLC();

    iDbAccess->BeginTransactionLC();

    PosLmLandmarkHandler::UpdateLandmarkL( *iDbAccess, aLandmark );

    NameIndex().UpdateL( aLandmark );

    iDbAccess->CommitTransactionAndPopL();

    CommitServerTransactionLX();

    CleanupStack::PopAndDestroy(); // DbLock

    User::LeaveIfError(

        RegisterEvent( EPosLmEventLandmarkUpdated, aLandmark.LandmarkId() ) );

    }

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

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

//

void CPosLmLocalDatabase::RemoveLandmarkL( TPosLmItemId aLandmarkId )

    {

    LeaveIfInitializingIsNeededL();

    iDiskUtilities->DiskSpaceBelowCriticalLevelL(

        iDiskUtilities->EstimatedDiskSizeOfLmOperation(

        CPosLmDiskUtilities::ERemoveLandmarkOp,

        aLandmarkId ), iDbDrive );

    AquireLockLC( EWriteLock );

    BeginServerTransactionLC();

    iDbAccess->BeginTransactionLC();

    PosLmLandmarkHandler::RemoveLandmarkL( *iDbAccess, aLandmarkId );

    NameIndex().RemoveL( aLandmarkId );

    iDbAccess->CommitTransactionAndPopL();

    CommitServerTransactionLX();

    CleanupStack::PopAndDestroy(); // DbLock

    User::LeaveIfError(

        RegisterEvent( EPosLmEventLandmarkDeleted, aLandmarkId ) );

    }

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

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

//

CPosLmOperation* CPosLmLocalDatabase::RemoveLandmarksL(

    const RArray<TPosLmItemId>& aLandmarkIdArray)

    {

    LeaveIfInitializingIsNeededL();

    iDiskUtilities->DiskSpaceBelowCriticalLevelL(

        iDiskUtilities->EstimatedDiskSizeOfLmOperation(

        CPosLmDiskUtilities::ERemoveLandmarksOp,

        aLandmarkIdArray), iDbDrive);

    return CPosLmLocalRemoveLandmarksOp::NewL(*this, aLandmarkIdArray);

    }

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

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

//

CPosLmOperation* CPosLmLocalDatabase::RemoveAllLandmarksL()

    {

    LeaveIfInitializingIsNeededL();

    return CPosLmLocalRemoveLandmarksOp::NewL(*this);

    }

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

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

//

CPosLmPartialReadParameters* CPosLmLocalDatabase::PartialReadParametersLC()

    {

    CPosLmPartialReadParameters* partialSettings =

        CPosLmPartialReadParameters::NewLC();

    CopyPartialSettingsL(*iPartialSettings, *partialSettings);

    return partialSettings;

    }

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

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

//

void CPosLmLocalDatabase::SetPartialReadParametersL(

    const CPosLmPartialReadParameters& aPartialSettings)

    {

    CPosLmPartialReadParameters* newSetting =

        CPosLmPartialReadParameters::NewLC();

    CopyPartialSettingsL(aPartialSettings, *newSetting);

    CleanupStack::Pop(newSetting);

    delete iPartialSettings;

    iPartialSettings = newSetting;

    }