/*

* 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: Handles landmark operations on a local landmark database.

*

*

*/

#include    <e32math.h>

#include    <lbsposition.h>

#include    <EPos_LandmarksErrors.h>

#include    <EPos_PosLmImplExtension.h>

#include    "EPos_PosLmLandmarkHandler.h"

#include    "EPos_CPosLmLocalDbAccess.h"

#include    "EPos_PosLmLongTextColHandler.h"

#include    "EPos_PosLmIconHandler.h"

#include    "EPos_PosLmCategoryHandler.h"

#include    "EPos_PosLmTrealCompare.h"

#include    "EPos_LandmarkDatabaseStructure.h"

#include    "EPos_PosLmDatabaseUtility.h"

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

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

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

//

EXPORT_C void PosLmLandmarkHandler::ReadLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark)

    {

    RDbView view;

    OpenLandmarkViewLC( aLandmark.LandmarkId(), view, aDbAccess );

    view.GetL();

    ReadLandmarkL( view, aDbAccess, aLandmark );

    CleanupStack::PopAndDestroy( &view );

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::ReadLandmarkL(

    RDbRowSet& aView,

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark)

    {

    RArray<TUint> dummy; // Not used here. All fields should be read.

    ReadLandmarkL( 

        aView, aDbAccess, aLandmark, CPosLandmark::EAllAttributes, EFalse, dummy);

    dummy.Close();

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::AddLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark)

    {

    AddBasicLandmarkInfoL(aDbAccess, aLandmark);

    AddFieldsL(aDbAccess, aLandmark);

    AddCategoriesL(aDbAccess, aLandmark);

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::UpdateLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    const CPosLandmark& aLandmark)

    {

    CPosLandmark* oldLandmark = CPosLandmark::NewLC();

    PosLmImplExtension::SetLandmarkIdL(*oldLandmark, aLandmark.LandmarkId());

    ReadLandmarkL(aDbAccess, *oldLandmark);

    UpdateCategoriesL(aDbAccess, aLandmark, *oldLandmark);

    UpdateFieldsL(aDbAccess, aLandmark, *oldLandmark);

    UpdateIconAndBasicLandmarkInfoL(aDbAccess, aLandmark, *oldLandmark);

    CleanupStack::PopAndDestroy(oldLandmark);

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::RemoveLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    TPosLmItemId aLandmarkId)

    {

    RemoveAllCategoriesFromLandmarkL(aDbAccess, aLandmarkId);

    RemoveAllFieldsFromLandmarkL(aDbAccess, aLandmarkId);

    TUint32 iconPathId;

    if (RemoveBasicLandmarkInfoL(aDbAccess, aLandmarkId, iconPathId))

        {

        PosLmIconHandler::RemoveIconIfNotUsedL(aDbAccess, iconPathId);

        }

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::ReadPartialLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark,

    CPosLmPartialReadParameters& aPartialSettings )

    {

    RDbView view;

    OpenLandmarkViewLC( aLandmark.LandmarkId(), view, aDbAccess );

    view.GetL();

    ReadPartialLandmarkL( view, aDbAccess, aLandmark, aPartialSettings );

    CleanupStack::PopAndDestroy( &view );

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::ReadPartialLandmarkL(

    RDbRowSet& aLandmarkView,

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark,

    CPosLmPartialReadParameters& aPartialSettings )

    {

    PosLmImplExtension::SetPartialL( aLandmark, ETrue );

    RArray<TUint> requestedFields;

    CleanupClosePushL( requestedFields );

    User::LeaveIfError(

        aPartialSettings.GetRequestedPositionFields( requestedFields ) );

    ReadLandmarkL( 

        aLandmarkView, aDbAccess, aLandmark, 

        aPartialSettings.RequestedAttributes(), ETrue, requestedFields );

    CleanupStack::PopAndDestroy( &requestedFields );

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::AddCategoriesToLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    const RArray<TPosLmItemId>& aCategories,

    const TPosLmItemId& aLandmarkId)

    {

    if (aCategories.Count() > 0)

        {

        HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

        sql->Des().Format(KPosLmSqlSelect, &KPosLmSqlAll,

            &KPosLmLandmarkCategoryTable);

        RDbView view;

        aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EAddPreparation, view,

            *sql);

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

            {

            view.InsertL();

            view.SetColL(EPosLmLccLandmarkIdCol, aLandmarkId);

            view.SetColL(EPosLmLccCategoryIdCol, aCategories[i]);

            view.PutL();

            }

        CleanupStack::PopAndDestroy(2, sql); //&view

        }

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::GetAllLandmarkIdsL(

    CPosLmLocalDbAccess& aDbAccess,

    TBool aUseSort,

    TBool aSortDescending,

    RArray<TPosLmItemId>& aLandmarkIds)

    {

    aLandmarkIds.Reset();

    HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

    if (aUseSort)

        {

        sql->Des().Format(KPosLmSqlSelectOrderByString, &KPosLmLandmarkIdCol,

            &KPosLmLandmarkTable, &KPosLmNameCol);

        if (aSortDescending)

            {

            sql->Des().Append(KPosLmSqlDescOrder);

            }

        }

    else

        {

        sql->Des().Format(KPosLmSqlSelect, &KPosLmLandmarkIdCol,

            &KPosLmLandmarkTable);

        }

    RDbView view;

    aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EUpdatablePreparation, view,

        *sql, EDbCompareCollated);

    aLandmarkIds.ReserveL( view.CountL() );

    while ( view.NextL() )

        {

        view.GetL();

        aLandmarkIds.Append( view.ColUint32(1) );

        }

    CleanupStack::PopAndDestroy(2, sql); //&view

    }

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

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

//

EXPORT_C TBool PosLmLandmarkHandler::LandmarkExistsL(

    CPosLmLocalDbAccess& aDbAccess,

    TPosLmItemId aLandmarkId)

    {

    HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

    sql->Des().Format(KPosLmSqlFindUint, &KPosLmLandmarkIdCol,

        &KPosLmLandmarkTable, &KPosLmLandmarkIdCol, aLandmarkId);

    RDbView view;

    aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EUpdatablePreparation, view,

        *sql);

    TBool exists = !view.IsEmptyL();

    CleanupStack::PopAndDestroy(2, sql); //&view

    return exists;

    }

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

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

//

EXPORT_C void PosLmLandmarkHandler::RemoveCategoryFromLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    TPosLmItemId aCategoryId,

    TPosLmItemId aLandmarkId)

    {

    // Remove category from all landmark.

    HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

    sql->Des().Format(KPosLmSqlDeleteBy2Uint, &KPosLmLandmarkCategoryTable,

        &KPosLmCategoryIdCol, aCategoryId, &KPosLmLandmarkIdCol, aLandmarkId);

    aDbAccess.ExecuteL(*sql);

    CleanupStack::PopAndDestroy(sql);

    }

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

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

//

EXPORT_C TBool PosLmLandmarkHandler::HasLandmarkSpecifiedCategoryL(

    CPosLmLocalDbAccess& aDbAccess,

    TPosLmItemId aCategoryId,

    TPosLmItemId aLandmarkId)

    {

    HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

    sql->Des().Format(

        KPosLmSqlFind2Uint, &KPosLmSqlAll, &KPosLmLandmarkCategoryTable,

        &KPosLmLandmarkIdCol, aLandmarkId, &KPosLmCategoryIdCol, aCategoryId);

    RDbView view;

    aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EUpdatablePreparation, view,

        *sql);

    TBool hasCategory = !view.IsEmptyL();

    CleanupStack::PopAndDestroy(2, sql); //&view

    return hasCategory;

    }

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

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

//

void PosLmLandmarkHandler::ReadLandmarkL(

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark,

    CPosLandmark::TAttributes aAttributes,

    TBool aHasRequestedFields,

    const RArray<TUint>& aRequestedFields )

    {

    RDbView view;

    OpenLandmarkViewLC( aLandmark.LandmarkId(), view, aDbAccess );

    view.GetL();

    ReadLandmarkL( 

        view, aDbAccess, aLandmark, aAttributes, aHasRequestedFields, aRequestedFields );

    CleanupStack::PopAndDestroy( &view );

    }

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

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

//

void PosLmLandmarkHandler::ReadLandmarkL(

    RDbRowSet& aView,

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark,

    CPosLandmark::TAttributes aAttributes,

    TBool aHasRequestedFields,

    const RArray<TUint>& aRequestedFields )

    {

    if ( aAttributes & CPosLandmark::ELandmarkName )

        {

        ReadNameL( aView, aLandmark );

        }

    if ( aAttributes & CPosLandmark::EPosition )

        {

        ReadPositionL( aView, aLandmark );

        }

    if ( aAttributes & CPosLandmark::ECoverageRadius )

        {

        ReadCoverageRadiusL( aView, aLandmark );

        }

    if ( aAttributes & CPosLandmark::EDescription )

        {

        ReadDescriptionL( aView, aLandmark );

        }

    if ( aAttributes & CPosLandmark::EIcon )

        {

        ReadIconL( aDbAccess, aView, aLandmark );

        }

    if ( aAttributes & CPosLandmark::ECategoryInfo )

        {

        ReadCategoriesL( aDbAccess, aLandmark );

        }

    ReadFieldsL( aDbAccess, aLandmark, aHasRequestedFields, aRequestedFields );

    }

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

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

//

void PosLmLandmarkHandler::ReadPositionL(

    RDbRowSet& aView,

    CPosLandmark& aLandmark)

    {

    if (!aView.IsColNull(EPosLmLcLatitudeCol) &&

        !aView.IsColNull(EPosLmLcLongitudeCol))

        {

        TLocality position;

        if (!aView.IsColNull(EPosLmLcAltitudeCol))

            {

            position.SetCoordinate(aView.ColReal64(EPosLmLcLatitudeCol),

                aView.ColReal64(EPosLmLcLongitudeCol),

                aView.ColReal32(EPosLmLcAltitudeCol));

            }

        else

            {

            position.SetCoordinate(aView.ColReal64(EPosLmLcLatitudeCol),

                aView.ColReal64(EPosLmLcLongitudeCol));

            }

        if (!aView.IsColNull(EPosLmLcHorizAccCol))

            {

            position.SetHorizontalAccuracy(

                aView.ColReal32(EPosLmLcHorizAccCol));

            }

        if (!aView.IsColNull(EPosLmLcVertAccCol))

            {

            position.SetVerticalAccuracy(aView.ColReal32(EPosLmLcVertAccCol));

            }

        aLandmark.SetPositionL(position);

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadCoverageRadiusL(

    RDbRowSet& aView,

    CPosLandmark& aLandmark)

    {

    if (!aView.IsColNull(EPosLmLcCoverageRadiusCol))

        {

        aLandmark.SetCoverageRadius(aView.ColReal32(EPosLmLcCoverageRadiusCol));

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadNameL(

    RDbRowSet& aView,

    CPosLandmark& aLandmark)

    {

    if (!aView.IsColNull(EPosLmLcNameCol))

        {

        HBufC* nameBuffer = HBufC::NewLC(KPosLmMaxTextFieldLength);

        TPtr buffer = nameBuffer->Des();

        PosLmLongTextColHandler::ReadFromLongTextColumnL(buffer, aView,

            EPosLmLcNameCol);

        aLandmark.SetLandmarkNameL(*nameBuffer);

        CleanupStack::PopAndDestroy(nameBuffer);

        }

    else

        {

        aLandmark.SetLandmarkNameL(KNullDesC);

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadDescriptionL(

	RDbRowSet& aView,

    CPosLandmark& aLandmark)

    {

    if (!aView.IsColNull(EPosLmLcDescriptionCol))

        {

        HBufC* description = HBufC::NewLC(KPosLmMaxDescriptionLength);

        TPtr descriptionBuffer = description->Des();

        PosLmLongTextColHandler::ReadFromLongTextColumnL(descriptionBuffer,

            aView, EPosLmLcDescriptionCol);

        aLandmark.SetLandmarkDescriptionL(*description);

        CleanupStack::PopAndDestroy(description);

        }

    else

        {

        aLandmark.SetLandmarkDescriptionL(KNullDesC);

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadIconL(

    CPosLmLocalDbAccess& aDbAccess,

    RDbRowSet& aView,

    CPosLandmark& aLandmark)

    {

    if (!aView.IsColNull(EPosLmLcIconIdCol) &&

        !aView.IsColNull(EPosLmLcIconPicNrCol) &&

        !aView.IsColNull(EPosLmLcMaskPicNrCol))

        {

        // Get icon path

        HBufC* iconPath = HBufC::NewLC(KMaxFileName);

        TPtr path = iconPath->Des();

        if (PosLmIconHandler::GetIconPathL(aDbAccess,

            aView.ColUint32(EPosLmLcIconIdCol), path) == KErrNone)

            {

            aLandmark.SetIconL(*iconPath,

                aView.ColInt32(EPosLmLcIconPicNrCol),

                aView.ColInt32(EPosLmLcMaskPicNrCol));

            }

        CleanupStack::PopAndDestroy(iconPath);

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadFieldsL(

    CPosLmLocalDbAccess& aDbAccess,

    CPosLandmark& aLandmark,

    TBool aHasRequestedFields,

    const RArray<TUint>& aRequestedFields)

    {

    if (!aHasRequestedFields || aRequestedFields.Count() > 0)

        {

        HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

        sql->Des().Format(KPosLmSqlFindUint, &KPosLmSqlAll,

            &KPosLmLandmarkFieldTable, &KPosLmLandmarkIdCol,

            aLandmark.LandmarkId());

        RDbView view;

        aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EUpdatablePreparation,

            view, *sql);

        HBufC* textFieldBuffer = HBufC::NewLC(KPosLmMaxTextFieldLength);

        while (view.NextL())

            {

            view.GetL();

            TUint16 fieldType = view.ColUint16(EPosLmLfcFieldTypeCol);

            if (!aHasRequestedFields ||

                aRequestedFields.Find(fieldType) != KErrNotFound)

                {

                TPtr buffer = textFieldBuffer->Des();

                PosLmLongTextColHandler::ReadFromLongTextColumnL(

                    buffer, view, EPosLmLfcFieldStringCol);

                aLandmark.SetPositionFieldL(fieldType, *textFieldBuffer);

                }

            }

        CleanupStack::PopAndDestroy(3, sql); //&view, textFieldBuffer

        }

    }

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

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

//

void PosLmLandmarkHandler::ReadCategoriesL(

    CPosLmLocalDbAccess& aDbAccess,