/*

* Copyright (c) 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:  See class description below.

*

*/

// INCLUDE FILES

#include <d32dbms.h>

#include <badesca.h>

#include <EPos_Landmarks.h>

#include <epos_poslmdatabaseutility.h>

#include <epos_cposlmdiskutilities.h>

#include <EPos_PosLmDbInfoExtension.h>

#include "EPos_CPosLmLocalDatabaseManager.h"

// CONSTANTS

const TInt KPosDbListGranularity = 2;

const TInt KDriveAndDelimiterLength = 2;

_LIT(KFileProtocol, "file");

_LIT(KProtocolDelimiter, "://");

_LIT(KFileExtension, ".ldb");

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

void CleanupRPointerArray(TAny* aArray)

    {

    (static_cast<RPointerArray<HPosLmDatabaseInfo>*>(

        aArray))->ResetAndDestroy();

    }

TBool MediaInfoIsEqual(const TMediaInfo& m1, const TMediaInfo& m2)

    {

    return m1.iDrive == m2.iDrive;

    }

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

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

// CPosLmLocalDatabaseManager::CPosLmLocalDatabaseManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPosLmLocalDatabaseManager::CPosLmLocalDatabaseManager()

    : CPosLmDatabaseManagerPluginBase()

    {

    }

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

// CPosLmLocalDatabaseManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPosLmLocalDatabaseManager::ConstructL()

    {

    User::LeaveIfError(iSubsession.Open(Session()));

    SynchronizeRegistryL();

    CreateDriveInfoListL();

    }

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

// CPosLmLocalDatabaseManager::NewL

// Two-phased constructor.

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

//

CPosLmLocalDatabaseManager* CPosLmLocalDatabaseManager::NewL(

    TAny* aConstructionParams)

    {

    CPosLmLocalDatabaseManager* self =

        new (ELeave) CPosLmLocalDatabaseManager();

    CleanupStack::PushL(self);

    self->BaseConstructL(aConstructionParams);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CPosLmLocalDatabaseManager::~CPosLmLocalDatabaseManager()

    {

    iSubsession.Close();

    iMediaInfoList.Close();

    }

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

// CPosLmLocalDatabaseManager::DatabaseMedia

//

// (other items were commented in a header).

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

//

TMediaType CPosLmLocalDatabaseManager::DatabaseMedia(

    const TDesC&  aDatabaseUri)

    {

    TMediaType result = EMediaUnknown;

    TMediaInfo searchItem;

    searchItem.iDrive = DatabaseDrive(aDatabaseUri);

    TInt index = iMediaInfoList.Find(

        searchItem,

        TIdentityRelation<TMediaInfo>(MediaInfoIsEqual));

    if (index != KErrNotFound)

        {

        result = iMediaInfoList[index].iMediaType;

        }

    return result;

    }

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

// CPosLmLocalDatabaseManager::DatabaseDrive

//

// (other items were commented in a header).

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

//

TChar CPosLmLocalDatabaseManager::DatabaseDrive(

    const TDesC&  aDatabaseUri)

    {

    TChar sysDriveChar = RFs::GetSystemDriveChar();

    // if protocol delimiter present,

    // verify that URI starts with "file://"

    TInt offset = aDatabaseUri.Find(KProtocolDelimiter);

    if (offset != KErrNotFound && aDatabaseUri.Left(offset) != KFileProtocol)

        {

        // wrong protocol

        return 0;

        }

    // adjust offset depending on whether or not protocol is present

    offset = offset == KErrNotFound ?

             0 :

             KFileProtocol().Length() + KProtocolDelimiter().Length();

    if (aDatabaseUri.Length() < offset + KDriveAndDelimiterLength)

        {

        return 0;

        }

    // if second character is ":", return first character

    // otherwise return default drive

    if (aDatabaseUri[offset + 1] == KDriveDelimiter)

        {

        return TChar(aDatabaseUri[offset]).GetUpperCase();

        }

    return sysDriveChar;

    }

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

// CPosLmLocalDatabaseManager::Protocol

//

// (other items were commented in a header).

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

//

TPtrC CPosLmLocalDatabaseManager::Protocol()

    {

    return TPtrC(KFileProtocol);

    }

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

// CPosLmLocalDatabaseManager::ListDatabasesLC

//

// (other items were commented in a header).

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

//

CDesCArray* CPosLmLocalDatabaseManager::ListDatabasesLC()

    {

    CDesCArray* dbArray = new (ELeave) CDesCArrayFlat(KPosDbListGranularity);

    CleanupStack::PushL(dbArray);

    RFs fs;

    CleanupClosePushL(fs);

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

    TDriveList driveList;

    User::LeaveIfError(fs.DriveList(driveList));

    RDbs dbSession;

    CleanupClosePushL(dbSession);

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

    for (TInt drive = EDriveA; drive <= EDriveZ; drive++)

        {

        if ( driveList[drive] && !( driveList[drive] & KDriveAttRemote ) ) // avoid remote drives

            {

            TDriveInfo drvInfo;

            TInt err = fs.Drive( drvInfo, drive );

            if ( !err && drvInfo.iType != EMediaNotPresent )

                {

                CDbDatabaseNames* dbNames = NULL;

                TRAPD(err, dbNames = dbSession.DatabaseNamesL(

                    static_cast<TDriveNumber>(drive), KPosLmDbSecureUid));

                // Ignore all errors except KErrNoMemory (and KErrNone)

                if (err == KErrNone)

                    {

                    CleanupStack::PushL(dbNames);

                    for (TInt i = 0; i < dbNames->Count(); i++)

                        {

                        TPtrC ptr = (*dbNames)[i];

                        if (ptr.Right(KFileExtension().Length()).

                            CompareF(KFileExtension) == 0)

                            {

                            HBufC* fullName = HBufC::NewLC(

                                KFileProtocol().Length() +

                                KProtocolDelimiter().Length() +

                                KDriveAndDelimiterLength +

                                (*dbNames)[i].Length());

                            TChar chr;

                            fs.DriveToChar(drive, chr);

                            TPtr ptr2 = fullName->Des();

                            ptr2.Append(KFileProtocol);

                            ptr2.Append(KProtocolDelimiter);

                            ptr2.Append(chr);

                            ptr2.Append(KDriveDelimiter);

                            ptr2.Append((*dbNames)[i]);

                            dbArray->AppendL(*fullName);

                            CleanupStack::PopAndDestroy(fullName);

                            }

                        }

                    CleanupStack::PopAndDestroy(dbNames);

                    }

                else if (err == KErrNoMemory)

                    {

                    User::Leave(err);

                    }

                }

            }

        }

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

    return dbArray;

    }

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

// CPosLmLocalDatabaseManager::ListDatabasesL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::ListDatabasesL(

    RPointerArray<HPosLmDatabaseInfo>& aDatabaseInfoArray)

    {

    // list URIs

    CDesCArray* dbUriArray = ListDatabasesLC();

    // list registered databases

    Session().ListDatabasesL(aDatabaseInfoArray, KFileProtocol);

    // delete from URI list those databases that are registered

    for (TInt i = aDatabaseInfoArray.Count() - 1; i >= 0; i--)

        {

        TInt index;

        if (dbUriArray->Find(aDatabaseInfoArray[i]->DatabaseUri(), index) == 0)

            {

            dbUriArray->Delete(index);

            }

        }

    // for each remaining URI in the list, fill in database info

    // and add to list

    TInt count = dbUriArray->Count();

    for (TInt i = 0; i < count; i++)

        {

        HPosLmDatabaseInfo* info = HPosLmDatabaseInfo::NewLC((*dbUriArray)[i]);

        aDatabaseInfoArray.AppendL(info);

        CleanupStack::Pop(info); // transfer of ownership to array

        }

    CleanupStack::PopAndDestroy(dbUriArray);

    // database drive, database media and default flag

    // will be filled in by database management provider.

    }

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

// CPosLmLocalDatabaseManager::RegisterDatabaseL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::RegisterDatabaseL(

               HPosLmDatabaseInfo& /* aDatabaseInfo */)

    {

    User::Leave(KErrNotSupported);

    }

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

// CPosLmLocalDatabaseManager::UnregisterDatabaseL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::UnregisterDatabaseL(

    const TDesC& /* aDatabaseUri */)

    {

    User::Leave(KErrNotSupported);

    }

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

// CPosLmLocalDatabaseManager::UnregisterAllDatabasesL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::UnregisterAllDatabasesL()

    {

    User::Leave(KErrNotSupported);

    }

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

// CPosLmLocalDatabaseManager::ModifyDatabaseSettingsL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::ModifyDatabaseSettingsL(

    const TDesC& aDatabaseUri,

    const TPosLmDatabaseSettings& aDatabaseSettings

        )

    {

    // validate URI

    HBufC* uri = PosLmDatabaseUtility::CreateDatabaseUriL(aDatabaseUri);

    CleanupStack::PushL(uri);

    if(!DatabaseExistsL(*uri))

        {

        User::Leave(KErrNotFound);

        }

    TChar drive = DatabaseDrive(*uri);

    TInt err = Session().ModifyDatabaseSettings(*uri,

                                                aDatabaseSettings,

                                                drive);

    if (err == KErrNotFound)

        {

        // database was not registered

        HPosLmDatabaseInfo* info =

            HPosLmDatabaseInfo::NewLC(*uri);

        info->Settings() = aDatabaseSettings;

        PosLmDbInfoExtension::SetDatabaseDrive(*info, drive);

        User::LeaveIfError(Session().RegisterDatabase(*info));

        CleanupStack::PopAndDestroy(info);

        }

    else if (err != KErrNone)

        {

        User::LeaveIfError(err);

        }

    // report event

    // To remove a warning, the event must be default constructed.

    TPosLmDatabaseEvent event =

        {

        EPosLmDbSettingsModified,

        {0,0,0,0,0,0,0,0}

        };

    User::LeaveIfError(Session().ReportEvent(event, *uri));

    CleanupStack::PopAndDestroy(uri);

    }

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

// CPosLmLocalDatabaseManager::GetDatabaseInfoL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::GetDatabaseInfoL(

    HPosLmDatabaseInfo& aDatabaseInfo

        )

    {

    // database drive, database media and default flag

    // will be filled in by database management provider.

    // must validate URI, copy to new object

    HBufC* uri = PosLmDatabaseUtility::CreateDatabaseUriL(

        aDatabaseInfo.DatabaseUri());

    CleanupStack::PushL(uri);

    if(!DatabaseExistsL(*uri))

        {

        User::Leave(KErrNotFound);

        }

    HPosLmDatabaseInfo* info = HPosLmDatabaseInfo::NewLC(*uri);

    PosLmDbInfoExtension::SetDatabaseDrive(

        *info,

        aDatabaseInfo.DatabaseDrive());

    TInt err = Session().GetDatabaseInfo(*info);

    if (err == KErrNone)

        {

        // database is registered, transfer settings to original object

        aDatabaseInfo.Settings() = info->Settings();

        }

    else if (err != KErrNotFound)

        {

        User::Leave(err);

        }

    // database is not registered - do nothing.

    CleanupStack::PopAndDestroy(2, uri); // info

    }

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

// CPosLmLocalDatabaseManager::DatabaseExistsL

//

// (other items were commented in a header).

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

//

TBool CPosLmLocalDatabaseManager::DatabaseExistsL(const TDesC& aDatabaseUri)

    {

    // validate URI

    HBufC* uri = PosLmDatabaseUtility::CreateDatabaseUriL(aDatabaseUri);

    CleanupStack::PushL(uri);

    TPtrC ptr(uri->Des());

    PosLmDatabaseUtility::RemoveProtocolFromUriL(ptr);

    TParse parse;

    User::LeaveIfError(parse.Set(ptr, NULL, NULL));

    TFileName searchUri = parse.NameAndExt();

    searchUri.UpperCase();

    TInt drive;

    User::LeaveIfError(RFs::CharToDrive(parse.Drive()[0], drive));

    RDbs dbSession;

    CleanupClosePushL(dbSession);

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

    CDbDatabaseNames* names = dbSession.DatabaseNamesL(

            static_cast<TDriveNumber>(drive), KPosLmDbSecureUid);

    CleanupStack::PushL(names);

    TBool exists(EFalse);

    for (TInt i = 0; i < names->Count() && !exists; i++)

        {

        HBufC* databaseName = (*names)[i].AllocLC();

        databaseName->Des().UpperCase();

        if (searchUri == *databaseName)

            {

            exists = ETrue;

            }

        CleanupStack::PopAndDestroy(databaseName);

        }

    CleanupStack::PopAndDestroy(3, uri);  //dbSession

    return exists;

    }

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

// CPosLmLocalDatabaseManager::CreateDatabaseL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::CreateDatabaseL(

    HPosLmDatabaseInfo& aDatabaseInfo)

    {

    // database drive and database media has been filled in by

    // database management provider.

    User::LeaveIfError(iSubsession.CreateDatabase(aDatabaseInfo));

    }

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

// CPosLmLocalDatabaseManager::DeleteDatabaseL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::DeleteDatabaseL(

    const TDesC&  aDatabaseUri)

    {

    HPosLmDatabaseInfo* info = HPosLmDatabaseInfo::NewLC(aDatabaseUri);

    PosLmDbInfoExtension::SetDatabaseDrive(*info,

                                           DatabaseDrive(aDatabaseUri));

    TInt err = iSubsession.DeleteDatabase(*info);

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

        {

        User::Leave(err);

        }

    CleanupStack::PopAndDestroy(info);

    }

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

// CPosLmLocalDatabaseManager::CopyDatabaseL

//

// (other items were commented in a header).

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

//

void CPosLmLocalDatabaseManager::CopyDatabaseL(

    const TDesC&  aSourceUri,

    const TDesC&  aTargetUri)

    {

    User::LeaveIfError(iSubsession.CopyDatabase(aSourceUri, aTargetUri));

    }

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

// CPosLmLocalDatabaseManager::SynchronizeRegistryL

//

// (other items were commented in a header).

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

//