/*

* 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: Provides static functions which handles database creation

*								and deletion.

*

*

*/

#include <d32dbms.h>

#include <EPos_Landmarks.h>

#include <epos_landmarkdatabasestructure.h>

#include <epos_poslmdatabaseutility.h>

#include "EPos_PosLmDatabaseManager.h"

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

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

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

//

void PosLmDatabaseManager::DeleteDatabaseL(

    const TDesC& aUri)

    {

    RDbs dbSession;

    CleanupClosePushL(dbSession);

    User::LeaveIfError(dbSession.Connect());

    TPtrC dbPath(aUri);

    PosLmDatabaseUtility::RemoveProtocolFromUriL(dbPath);

    User::LeaveIfError(dbSession.DeleteDatabase(dbPath, KPosLmDbSecureUid));

    CleanupStack::PopAndDestroy(&dbSession);

    }

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

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

//

void PosLmDatabaseManager::CreateDatabaseL(

    const TDesC& aUri,

    TBool aDefaultDatabase,

    TBool aReplaceDatabase)

    {

    RDbs dbSession;

    CleanupClosePushL(dbSession);

    User::LeaveIfError(dbSession.Connect());

    TPtrC dbPath(aUri);

    PosLmDatabaseUtility::RemoveProtocolFromUriL(dbPath);

    RDbNamedDatabase db;

    CleanupClosePushL(db);

    if (aDefaultDatabase && aReplaceDatabase)

        {

        TInt delerr = dbSession.DeleteDatabase(dbPath, KPosLmDbSecureUid);

        if (delerr != KErrNone && delerr != KErrNotFound)

            {

            User::Leave(delerr);

            }

        }

    TInt createerr = db.Create(dbSession, dbPath, KPosLmDbSecureFormat);

    if (!aDefaultDatabase ||

        (aDefaultDatabase && createerr != KErrAlreadyExists))

        {

        User::LeaveIfError(createerr);

        }

    if (createerr == KErrNone)

        {

        CreateTablesL(db);

        CreateIndexesL(db);

        SetCounterToOneL(db, KPosLmLandmarkTable);

        SetCounterToOneL(db, KPosLmCategoryTable);

        // The settings table is created last so that a database can be

        // validated when opening it (there will be a check for language there

        // which is a part of the settings table).

        CreateSettingsTableL(db);

        }

    CleanupStack::PopAndDestroy(2, &dbSession); // &db

    }

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

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

//

void PosLmDatabaseManager::CopyDatabaseL(

    const TDesC& aSourceUri,

    const TDesC& aTargetUri)

    {

    RDbs dbSession;

    CleanupClosePushL(dbSession);

    User::LeaveIfError(dbSession.Connect());

    TPtrC sourceDbPath(aSourceUri);

    TPtrC targetDbPath(aTargetUri);

    PosLmDatabaseUtility::RemoveProtocolFromUriL(sourceDbPath);

    PosLmDatabaseUtility::RemoveProtocolFromUriL(targetDbPath);

    User::LeaveIfError(dbSession.CopyDatabase(sourceDbPath,

                                              targetDbPath,

                                              KPosLmDbSecureUid));

    CleanupStack::PopAndDestroy(&dbSession);

    }

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

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

//

void PosLmDatabaseManager::CreateTablesL(

    RDbNamedDatabase& aDb)

    {

    CreateLandmarkTableL(aDb);

    CreateLandmarkFieldTableL(aDb);

    CreateCategoryTableL(aDb);

    CreateLmCategoryTableL(aDb);

    CreateIconTableL(aDb);

    // Do not create settings table here. This is created in the end so that the

    // database can be validated when opening it.

    }

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

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

//

void PosLmDatabaseManager::CreateLandmarkTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmLatitudeCol, EDbColReal64));

    columns->AddL(TDbCol(KPosLmLongitudeCol, EDbColReal64));

    columns->AddL(TDbCol(KPosLmAltitudeCol, EDbColReal32));

    columns->AddL(TDbCol(KPosLmHorizAccCol, EDbColReal32));

    columns->AddL(TDbCol(KPosLmVertAccCol, EDbColReal32));

    columns->AddL(TDbCol(KPosLmCoverageRadiusCol, EDbColReal32));

    columns->AddL(TDbCol(KPosLmIconIdCol, EDbColUint32));

    columns->AddL(TDbCol(KPosLmIconPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmMaskPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmNameCol, EDbColLongText,

        KPosLmMaxTextFieldLength));

    columns->AddL(TDbCol(KPosLmNDescCol, EDbColLongText,

        KPosLmMaxDescriptionLength));

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateLandmarkFieldTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.ENotNull;

    columns->AddL(TDbCol(col));

    TDbCol col2(KPosLmFieldTypeCol, EDbColUint16);

    col2.iAttributes = col2.ENotNull;

    columns->AddL(col2);

    columns->AddL(TDbCol(KPosLmFieldStringCol, EDbColLongText,

        KPosLmMaxTextFieldLength));

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkFieldTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateCategoryTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmCategoryIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmGlobalCategoryIdCol, EDbColUint16));

    columns->AddL(TDbCol(KPosLmIconIdCol, EDbColUint32));

    columns->AddL(TDbCol(KPosLmIconPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmMaskPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmCategoryNameCol, EDbColText,

        KPosLmMaxCategoryNameLength));

    columns->AddL(TDbCol(KPosLmCategoryNameModifiedCol, EDbColBit));

    User::LeaveIfError(aDb.CreateTable(KPosLmCategoryTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateLmCategoryTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.ENotNull;

    columns->AddL(col);

    TDbCol col2(KPosLmCategoryIdCol, EDbColUint32);

    col2.iAttributes = col2.ENotNull;

    columns->AddL(col2);

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkCategoryTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateIconTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmIconIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmIconPathCol, EDbColLongText, KMaxFileName));

    User::LeaveIfError(aDb.CreateTable(KPosLmIconTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateSettingsTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    columns->AddL(TDbCol(KPosLmLanguageCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmInitFlagCol, EDbColInt32));

    User::LeaveIfError(aDb.CreateTable(KPosLmSettingsTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

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

//

void PosLmDatabaseManager::CreateIndexTableL( RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    columns->AddL( TDbCol( KPosLmLanguageCol, EDbColInt32 ) );

    columns->AddL( TDbCol( KPosLmTimestampCol, EDbColDateTime ) );

    columns->AddL( TDbCol( KPosLmIndexDataCol, EDbColLongBinary ) );

    User::LeaveIfError( aDb.CreateTable( KPosLmIndexTable, *columns ) );

    CleanupStack::PopAndDestroy( columns );

    }

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

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

//

void PosLmDatabaseManager::CreateIndexesL( RDbNamedDatabase& aDb )

    {

    CreateIndexL(aDb, KPosLmLandmarkIdIndex, KPosLmLandmarkTable,

        KPosLmLandmarkIdCol, ETrue);

    CreateIndexL(aDb, KPosLmCategoryIdIndex, KPosLmCategoryTable,

        KPosLmCategoryIdCol, ETrue);

    CreateIndexL(aDb, KPosLmGlobalCategoryIdIndex, KPosLmCategoryTable,

        KPosLmGlobalCategoryIdCol, EFalse);

    CreateIndexL(aDb, KPosLmCategoryNameIndex, KPosLmCategoryTable,

        KPosLmCategoryNameCol, ETrue);

    CreateIndexL(aDb, KPosLmIconIdIndex, KPosLmIconTable,

        KPosLmIconIdCol, ETrue);

    CreateIndexL(aDb, KPosLmFieldsLmIdIndex, KPosLmLandmarkFieldTable,

        KPosLmLandmarkIdCol, EFalse);

    CreateIndexL(aDb, KPosLmCategoryLmIdIndex, KPosLmLandmarkCategoryTable,

        KPosLmLandmarkIdCol, EFalse);

    }

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

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

//

void PosLmDatabaseManager::CreateIndexL(

    RDbNamedDatabase& aDb,

    const TDesC& aIndex,

    const TDesC& aTable,

    const TDesC& aColumn,

    TBool aUnique)

    {

    CDbKey* keys = CDbKey::NewLC();

    keys->AddL(TDbKeyCol(aColumn));

    if (aUnique)

        {

        keys->MakeUnique();

        }

    User::LeaveIfError(aDb.CreateIndex(aIndex, aTable, *keys));

    CleanupStack::PopAndDestroy(keys);

    }

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

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

//

void PosLmDatabaseManager::SetCounterToOneL(

    RDbNamedDatabase& aDb,

    const TDesC& aTable)

    {

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

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

    RDbView view;

    CleanupClosePushL(view);

    User::LeaveIfError(view.Prepare(aDb, TDbQuery(*sql),

        TDbWindow::EUnlimited));

    view.InsertL();

    view.PutL();

    if (!view.FirstL())

        {

        User::Leave(KErrGeneral);

        }

    view.DeleteL();

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

    }