/*

* Copyright (c) 2005-2006 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:  javaregserversession implementation

*

*/

#include "javaregserversession.h"

#include "javaregdef.h"

#include "javaregproperty.h"

#include "javapropertyarray.h"

#include "javareguidarrayconv.h"

#include "javaregserver.h"

#include "logger.h"

using namespace Java::Manager::Registry;

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

// Constructor

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

CJavaRegServerSession::CJavaRegServerSession() :

        iBackupSession(EFalse),

        iLegacy(EFalse)

{

}

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

// Destructor

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

CJavaRegServerSession::~CJavaRegServerSession()

{

    // if it was a backup session move registry back to NoBackup state

    if (iBackupSession)

    {

        Server()->SetBackupState(ENoBackup);

    }

}

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

// Returns the iLegacy member

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

TBool CJavaRegServerSession::IsLegacy() const

{

    return iLegacy;

}

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

// Returns server object

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

CJavaRegServer* CJavaRegServerSession::Server() const

{

    return const_cast< CJavaRegServer* >(

               static_cast< const CJavaRegServer* >(CSession2::Server()));

}

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

// ServiceL

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

void CJavaRegServerSession::ServiceL(const RMessage2& aMessage)

{

    TRAPD(err, DispatchMessageL(aMessage));

    aMessage.Complete(err);

}

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

// DispatchMessageL

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

void CJavaRegServerSession::DispatchMessageL(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::DispatchMessageL()");

    TInt function = aMessage.Function();

    switch (function)

    {

    case EInitializeServerUseIntegr:

        InitializeServerUseIntegrL(aMessage);

        break;

    case EEntryExists:

        EntryExistsL(aMessage);

        break;

    case EGetEntryUids:

        GetEntryUidsL(aMessage);

        break;

    case EGetEntry:

    {

        GetEntryL(aMessage);

        break;

    }

    case EGetEntryFromAll:

    {

        GetEntryL(aMessage, ETrue);

    }

    break;

    case EFindEntries:

        FindEntriesL(aMessage);

        break;

    case EFindAllEntries:

        FindAllEntriesL(aMessage);

        break;

    case ESetBackupState:

        SetBackupState(aMessage);

        break;

    default:

        User::Leave(KErrNotSupported);

    }

}

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

// InitializeServerUseIntegrL

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

void CJavaRegServerSession::InitializeServerUseIntegrL(

    const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::InitializeServerUseIntegrL()");

    TBool useIntegrity = aMessage.Int0();

    iLegacy = aMessage.Int1();

    if (useIntegrity)

    {

        TTime currentTime;

        currentTime.UniversalTime();

        TInt64 transactionId = currentTime.Int64();

    }

}

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

// EntryExistsL

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

void CJavaRegServerSession::EntryExistsL(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::EntryExistsL()");

    Server()->LeaveIfRestoringL();

    // obtain uid

    TUid uid = UidFromMessageL(0, aMessage);

    // check if entry exists for uid

    TBool result = Server()->EntryExistsL(uid);

    // write back result

    TPckgBuf<TBool> resultBuf(result);

    aMessage.WriteL(1, resultBuf) ;

}

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

// GetEntryUidsL

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

void CJavaRegServerSession::GetEntryUidsL(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::GetEntryUidsL()");

    Server()->LeaveIfRestoringL();

    TInt drive = aMessage.Int2();

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    Server()->GetEntryUidsL(uids, drive);

    WriteBackUidArrayL(uids, aMessage) ;

    CleanupStack::PopAndDestroy(&uids);

}

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

// GetEntryL

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

void CJavaRegServerSession::GetEntryL(const RMessage2& aMessage,

                                      TBool aAllEntries)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::GetEntryL()");

    Server()->LeaveIfRestoringL();

    // read uid

    TUid uid = UidFromMessageL(2, aMessage);

    // get property

    CJavaPropertyArray* props = NULL;

    Server()->GetEntryL(uid, props, aAllEntries);

    TInt neededLength = 0;

    // if there is property write it back

    if (props)

    {

        CleanupStack::PushL(props);

        TInt allocatedLength = aMessage.GetDesMaxLengthL(0);

        neededLength = props->Size();

        if (allocatedLength >= neededLength)

        {

            HBufC8* propBuffer = props->SerializedPropertiesL();

            CleanupStack::PushL(propBuffer);

            aMessage.WriteL(0, propBuffer->Des());

            CleanupStack::PopAndDestroy(propBuffer);

        }

        else

        {

            WLOG(EJavaStorage,

                 "Allocated length is to small. Send back the needed length.");

        }

        // Delete because not cached.

        props->DeleteProperties();

        CleanupStack::PopAndDestroy(props);

    }

    // write back needed length

    TPckgBuf<TInt> lengthPckg(neededLength);

    aMessage.WriteL(1, lengthPckg);

}

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

// FindEntries

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

void CJavaRegServerSession::FindEntriesL(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::FindEntriesL()");

    Server()->LeaveIfRestoringL();

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    // read properties

    CJavaPropertyArray* props = PropertiesFromMessageL(2, aMessage);

    CleanupStack::PushL(props);

    Server()->FindEntriesL(*props, uids);

    CleanupStack::PopAndDestroy(props);

    WriteBackUidArrayL(uids, aMessage) ;

    CleanupStack::PopAndDestroy(&uids);

}

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

// FindAllEntries

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

void CJavaRegServerSession::FindAllEntriesL(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::FindEntriesL()");

    Server()->LeaveIfRestoringL();

    RArray<TUid> uids;

    CleanupClosePushL(uids);

    // read properties

    CJavaPropertyArray* props = PropertiesFromMessageL(2, aMessage);

    CleanupStack::PushL(props);

    Server()->FindAllEntriesL(*props, uids);

    CleanupStack::PopAndDestroy(props);

    WriteBackUidArrayL(uids, aMessage) ;

    CleanupStack::PopAndDestroy(&uids);

}

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

// SetBackupState

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

void CJavaRegServerSession::SetBackupState(const RMessage2& aMessage)

{

    JELOG(EJavaStorage, "CJavaRegServerSession::SetBackupState()");

    TBackupState state = (TBackupState) aMessage.Int0();

    Server()->SetBackupState(state);

    iBackupSession = ETrue;

}

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

// UidFromMessageL

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

TUid CJavaRegServerSession::UidFromMessageL(TInt aIndex,

        const RMessage2&  aMessage)

{

    TUid uid = TUid::Uid(0);

    TPckg<TUid> uidPack(uid);

    aMessage.ReadL(aIndex, uidPack);

    return uid;

}

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

// PropertiesFromMessageL

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

CJavaPropertyArray* CJavaRegServerSession::PropertiesFromMessageL(

    TInt aIndex,

    const RMessage2&  aMessage)

{

    TInt length = aMessage.GetDesLengthL(aIndex);

    HBufC8* propBuffer = HBufC8::NewLC(length);

    TPtr8 ptr = propBuffer->Des();

    aMessage.ReadL(aIndex, ptr);

    CJavaPropertyArray* props = CJavaPropertyArray::NewL(propBuffer);

    CleanupStack::PopAndDestroy(propBuffer);

    return props;

}

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

// WriteBackUidArrayL

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

void CJavaRegServerSession::WriteBackUidArrayL(RArray<TUid>& aUids,

        const RMessage2&  aMessage)

{

    HBufC16* uidBuffer = NULL;

    JavaRegUidArrayConverter::StoreTUidsL(aUids, uidBuffer);

    CleanupStack::PushL(uidBuffer);

    TInt allocatedLength = aMessage.GetDesMaxLengthL(0);

    TInt neededLength = uidBuffer->Length();

    if (allocatedLength >= neededLength)

    {

        aMessage.WriteL(0, uidBuffer->Des());

    }

    else

    {

        WLOG(EJavaStorage,

             "Allocated length is to small. Send back the needed length.");

    }

    CleanupStack::PopAndDestroy(uidBuffer);

    // write back needed length

    TPckgBuf<TInt> lengthPckg(neededLength);

    aMessage.WriteL(1, lengthPckg);

}