/*

* 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: Subsession class for local database management operations

*

*

*/

#include <EPos_TPosLmDatabaseEvent.h>

#include <epos_cposlmdiskutilities.h>

#include <epos_poslmdatabaseutility.h>

#include <EPos_HPosLmDatabaseInfo.h>

#include <EPos_CPosLmDbRegistry.h>

#include "EPos_CPosLmLocalDbManSubsession.h"

#include "EPos_CPosLmServer.h"

#include "EPos_PosLmServerCommon.h"

#include "EPos_LmServerGlobal.h"

#include "EPos_PosLmDatabaseManager.h"

#include "EPos_LandmarksServerPanics.h"

//CONSTANTS

/*   Comment on KPosMaxUriLength:

*    KPosMaxUriLength = KDbMaxName + 9;

*    KDbMaxName is the maximum length for a DBMS name: 64 characters.

*    Length of "file://c:" is 9.

*/

const TInt KPosMaxUriLength = 73;

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

// CPosLmLocalDbManSubsession::CPosLmLocalDbManSubsession

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

// might leave.

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

//

CPosLmLocalDbManSubsession::CPosLmLocalDbManSubsession(

    CPosLmServer* aLmServer) :

    CPosLmSubsessionBase(EPosLocalDbManProviderSubsession, aLmServer)

    {

    }

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

// CPosLmLocalDbManSubsession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPosLmLocalDbManSubsession::ConstructL()

    {

    }

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

// CPosLmLocalDbManSubsession::NewLC

// Two-phased constructor.

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

//

CPosLmLocalDbManSubsession* CPosLmLocalDbManSubsession::NewLC(

    CPosLmServer* aLmServer)

    {

    CPosLmLocalDbManSubsession* self =

        new (ELeave) CPosLmLocalDbManSubsession(aLmServer);

    CleanupClosePushL(*self);

    self->ConstructL();

    return self;

    }

// Destructor

CPosLmLocalDbManSubsession::~CPosLmLocalDbManSubsession()

    {

    }

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

// CPosLmLocalDbManSubsession::ServiceL

//

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

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

//

void CPosLmLocalDbManSubsession::ServiceL(

    const RMessage2& aMessage)

    {

    switch (aMessage.Function())

        {

        case EPosLmServerCreateDatabase:

        case EPosLmServerDeleteDatabase:

            HandleDbManagementOperationL(aMessage);

            break;

        case EPosLmServerCopyDatabase:

            HandleDbCopyOperationL(aMessage);

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    }

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

// CPosLmLocalDbManSubsession::HandleDbManagementOperationL

//

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

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

//

void CPosLmLocalDbManSubsession::HandleDbManagementOperationL(

    const RMessage2& aMessage)

    {

    TInt dbInfoLength = aMessage.GetDesLength(KPosLmServerDbInfoArg);

    if (dbInfoLength < 0)

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    HBufC8* buf = HBufC8::NewLC(dbInfoLength);

    TPtr8 bufPtr = buf->Des();

    if (LmServerGlobal::Read(

        aMessage, KPosLmServerDbInfoArg, bufPtr) == KErrNone)

        {

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

        TPosLmDatabaseEvent event =

            {

            EPosLmDbDatabaseRegistered,

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

            };

        TUint8* dbInfoPtr = const_cast<TUint8*>(buf->Ptr());

        HPosLmDatabaseInfo* dbInfo =

            reinterpret_cast<HPosLmDatabaseInfo*>(dbInfoPtr);

        // verify that dbInfo size is the same as the transferred descriptor

        if(bufPtr.Length() != dbInfo->Size())

            {

            PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

            CleanupStack::PopAndDestroy(buf);

            return;

            }

        HBufC* uri =

            PosLmDatabaseUtility::CreateDatabaseUriL(dbInfo->DatabaseUri());

        CleanupStack::PushL(uri);

        CPosLmDbRegistry* reg =

            Server()->GetRegistryL(dbInfo->DatabaseDrive(), ETrue);

        if (!reg)

            {

            User::Leave(KErrGeneral);

            }

        if (aMessage.Function() == EPosLmServerCreateDatabase)

            {

            // create on disk

            CheckDiskSizeL(*uri);

            PosLmDatabaseManager::CreateDatabaseL(*uri, EFalse);

            // register

            if (dbInfo->Settings().IsAttributeSet(

                TPosLmDatabaseSettings::EName))

                {

                reg->RegisterDatabaseL(*uri, dbInfo->Settings());

                User::LeaveIfError(reg->Compact());

                }

            }

        else

            {

            // a local db URI may not exceed KPosMaxUriLength

            if (uri->Length() > KPosMaxUriLength)

                {

                User::Leave(KErrArgument);

                }

            event.iEventType = EPosLmDbDatabaseUnregistered;

            // unregister

            reg->UnregisterDatabaseL(*uri);

            // delete from disk

            PosLmDatabaseManager::DeleteDatabaseL(*uri);

            }

        Server()->ForwardEventToAllSessionsL(event, *uri);

        CleanupStack::PopAndDestroy(uri);

        LmServerGlobal::Complete(aMessage, KErrNone);

        }

    CleanupStack::PopAndDestroy(buf);

    }

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

// CPosLmLocalDbManSubsession::HandleDbCopyOperationL

//

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

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

//

void CPosLmLocalDbManSubsession::HandleDbCopyOperationL(

    const RMessage2& aMessage)

    {

    TInt srcDesLength = aMessage.GetDesLength(KPosLmServerSourceUriArg);

    TInt trgDesLength = aMessage.GetDesLength(KPosLmServerTargetUriArg);

    if (srcDesLength < 0 || trgDesLength < 0)

        {

        PanicClient(aMessage, EPosUnableToReadOrWriteDataToClient);

        return;

        }

    HBufC* srcUri = HBufC::NewLC(srcDesLength);

    HBufC* trgUri = HBufC::NewLC(trgDesLength);

    TPtr srcUriPtr = srcUri->Des();

    TPtr trgUriPtr = trgUri->Des();

    if (LmServerGlobal::Read(aMessage,

                             KPosLmServerSourceUriArg,

                             srcUriPtr) == KErrNone &&

        LmServerGlobal::Read(aMessage,

                             KPosLmServerTargetUriArg,

                             trgUriPtr) == KErrNone)

        {

        HBufC* sourceUri = PosLmDatabaseUtility::CreateDatabaseUriL(*srcUri);

        CleanupStack::PushL(sourceUri);

        HBufC* targetUri = PosLmDatabaseUtility::CreateDatabaseUriL(*trgUri);

        CleanupStack::PushL(targetUri);

        CheckDiskSizeForCopyL(*sourceUri, *targetUri);

        PosLmDatabaseManager::CopyDatabaseL(*sourceUri, *targetUri);

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

        TPosLmDatabaseEvent event =

            {

            EPosLmDbDatabaseRegistered,

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

            };

        Server()->ForwardEventToAllSessionsL(event, *targetUri);

        CleanupStack::PopAndDestroy(2, sourceUri); // targetUri

        LmServerGlobal::Complete(aMessage, KErrNone);

        }

    CleanupStack::PopAndDestroy(2, srcUri); // trgUri

    }

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

// CPosLmLocalDbManSubsession::CheckDiskSizeL

//

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

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

//

void CPosLmLocalDbManSubsession::CheckDiskSizeL(

    const TDesC& aUri)

    {

    CPosLmDiskUtilities* diskUtilities = CPosLmDiskUtilities::NewL();

    CleanupStack::PushL(diskUtilities);

    diskUtilities->DiskSpaceBelowCriticalLevelL(

        diskUtilities->EstimatedDiskSizeOfEmptyDatabase(),

        (aUri)[KPosLocalDbFileProtocol().Length()]);

    CleanupStack::PopAndDestroy(diskUtilities);

    }

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

// CPosLmLocalDbManSubsession::CheckDiskSizeForCopyL

//

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

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

//

void CPosLmLocalDbManSubsession::CheckDiskSizeForCopyL(

    const TDesC& aSourceUri, const TDesC& aTargetUri)

    {

        // check size of existing database

    RDbs dbSession;

    RDbNamedDatabase db;

    CleanupClosePushL(dbSession);

    CleanupClosePushL(db);

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

    TPtrC sourceFile = aSourceUri;

    PosLmDatabaseUtility::RemoveProtocolFromUriL(sourceFile);

    User::LeaveIfError(db.Open(dbSession, sourceFile, KPosLmDbSecureFormat));

    TInt err = db.UpdateStats();

    if (err == KErrLocked)

        {

        err = KErrInUse;

        }

    User::LeaveIfError(err);

    TInt size = db.Size().iSize;

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

    CPosLmDiskUtilities* diskUtilities = CPosLmDiskUtilities::NewL();

    CleanupStack::PushL(diskUtilities);

    diskUtilities->DiskSpaceBelowCriticalLevelL(size,

        (aTargetUri)[KPosLocalDbFileProtocol().Length()]);

    CleanupStack::PopAndDestroy(diskUtilities);

    }

// End of File