/*

* Copyright (c) 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:  Session implementation class for Content Manager

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <s32mem.h>

#include    "cmcommon.h"

#include    "cmfillrulecontainer.h"

#include    "cmfillrule.h"

#include    "cmstorerulecontainer.h"

#include    "cmstorerule.h"

#include    "cmbaselistitem.h"

#include    "cmdmmain.h"

#include    "cmsettingsfactory.h"

#include    "cmsettings.h"

#include    "cmmediaserverfull.h"

#include    "cmsqlpropertycontainer.h"

#include    "cmsqlpropertycollector.h"

#include    "cmdriveinfo.h"

#include    "cmserversession.h"

#include    "cmserver.h"

#include    "msdebug.h"

// data buffer size

const TInt KBufferExpandSize = KKilo;

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

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

// CCmSession::CCmSession

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

//

CCmSession::CCmSession( CCmDmMain& aDbManager, MCmSettings& aSettings )

    : iDbManager( aDbManager ), iSettings( aSettings )

    {

    }

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

// CCmSession::NewL

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

//

CCmSession* CCmSession::NewL( CCmDmMain& aDbManager,

                              MCmSettings& aSettings )

    {

    LOG(_L("[Cm Server]\t CCmSession::NewL"));

    CCmSession* self =

        new (ELeave) CCmSession( aDbManager, aSettings );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCmSession::ConstructL

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

//

void CCmSession::ConstructL()

    {

    LOG(_L("[Cm Server]\t CCmSession::ConstructL"))

    iCollector = CCmSqlPropertyCollector::NewL();

    }

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

// CCmSession::~CCmSession

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

//

CCmSession::~CCmSession()

    {

    LOG(_L("[Cm Server]\t CCmSession::~CCmSession"));

    delete iDataBuffer;

    Server().DecrementSessions();

    delete iCollector;

    }

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

// CCmSession::Server

// Returns a reference to server

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

//

CCmServer& CCmSession::Server()

    {

    LOG(_L("[Cm Server]\t CCmSession::Server"));

    return *static_cast<CCmServer*>(const_cast<CServer2*>

        (CSession2::Server()));

    }

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

// CCmSession::ServiceL

// Implements CSession2 -derived ServiceL -method.

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

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

//

void CCmSession::ServiceL(const RMessage2& aMessage)

    {

    LOG(_L("[Cm Server]\t CCmSession::ServiceL"));

    switch ( aMessage.Function() )

        {

        case ECmExecuteService:

            {

            LOG(_L("[Cm Server]\t ECmExecuteService request"));

            TCmService service = (TCmService)aMessage.Int0();

            TRACE( Print (_L("[Cm Server]\t CCmSession::\

            ServiceL ECmExecuteService service = %d\n"), service ));

            Server().SetCurrentAsyncMsg( aMessage );

            Server().ExecuteServiceL( service );

            break;

            }

        case ECmCancel:

            {

            LOG(_L("[Cm Server]\t ECmCancel request"));

            Server().CancelServiceL();

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetServerState:

            {

            LOG(_L("[Cm Server]\t ECmGetServerState request"));

            TPckg<TCmServerState> pckg( Server().ServerState() );

            aMessage.WriteL(0, pckg );

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetServiceState:

            {

            LOG(_L("[Cm Server]\t ECmGetServiceState request"));

            TCmService service = static_cast<TCmService>(aMessage.Int0());

            TRACE( Print (_L("[Cm Server]\t CCmSession::\

            ServiceL ECmGetServiceState service = %d\n"), service ));

            TCmServiceState state = ECmServiceStateDisabled;

            TInt err( KErrNone );

            switch ( service )

                {

                case ECmServiceFill:  // fall through

                case ECmServiceStore: // fall through

                case ECmServiceContentManager:

                    {

                    iSettings.GetServiceState( ECmServiceContentManager,

                                               state );

                    if ( state )

                        {

                        TBool autoSync = EFalse;

                        iSettings.GetAutoSync( autoSync );

                        if ( autoSync )

                            {

                            state = ECmServiceStateAutomatic;

                            }

                        else

                            {

                            LOG(_L("[Cm Server]\t ECmGetServiceState \

                            request autosync = disabled"));

                            }

                        }

                    else

                        {

                        LOG(_L("[Cm Server]\t ECmGetServiceState request \

                        state = ECmServiceStateDisabled"));

                        }

                    break;

                    }

                case ECmServiceMemoryManager:

                    {

                    TBool mm = EFalse;

                    iSettings.GetMemoryManagerStatus( mm );

                    state = ECmServiceStateAutomatic;

                    if ( !mm )

                        {

                        state = ECmServiceStateDisabled;

                        }

                    break;

                    }

                default:

                    {

                    err = KErrArgument;

                    break;

                    }

                }

            TPckg<TCmServiceState> pckg( state );

            aMessage.WriteL(1, pckg );

            aMessage.Complete( err );

            break;

            }

        case ECmSetServiceState:

            {

            LOG(_L("[Cm Server]\t ECmSetServiceState request"));

            TCmService service = static_cast<TCmService>(aMessage.Int0());

            TCmServiceState state =

                static_cast<TCmServiceState>(aMessage.Int1());

            TRACE(Print(_L("[Cm Server]\t service %d state %d \n"),

                service, state ));

            Server().SetServiceStateL( service, state );

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetItemCount:

            {

            LOG(_L("[Cm Server]\t ECmGetItemCount request"));

            TCmService service = static_cast<TCmService>(aMessage.Int2());

            TRACE( Print (_L("[Cm Server]\t CCmSession::\

            ServiceL ECmGetItemCount service = %d\n"), service ));

            TInt len = aMessage.GetDesLength( 3 );

            if( len <= 0 )

                {

                LOG(_L("[Cm Server]\t ECmGetItemCount request \

                leaving with KErrArgument"));

                User::Leave( KErrArgument );

                }

            HBufC8* name = HBufC8::NewLC( len );

            TPtr8 ptr( name->Des() );

            aMessage.ReadL( 3, ptr );

            TInt64 size = 0;

            TInt count = 0;

            if ( service == ECmServiceFill )

                {

                size = iDbManager.ListSize(

                    ECmFmFillRule,

                    *name,

                    ECmFilled | ECmToBeFilled | ECmToBeShrinked

                );

                iDbManager.GetFillFileCount(

                    *name,

                    ECmFilled | ECmToBeFilled | ECmToBeShrinked,

                    count

                );

                TRACE(Print(_L("[Cm Server]\t got fill size %ld count %d"),

                    size, count));

                }

            else // ECmServiceStore

                {

                size = iDbManager.ListSize(

                    ECmFmStoreRule,

                    *name,

                    ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice

                );

                iDbManager.GetStoreFileCount(

                    *name,

                    ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice,

                    count

                );

                TRACE(Print(_L("[Cm Server]\t got store size %ld count %d"),

                    size, count));

                }

            CleanupStack::PopAndDestroy( name );

            TPckg<TInt> countPckg( count );

            TPckg<TInt64> sizePckg( size );

            aMessage.WriteL( 0, countPckg );

            aMessage.WriteL( 1, sizePckg );

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetTransferInfo:

            {

            LOG(_L("[Cm Server]\t ECmGetTransferInfo request"));

            TCmService service = static_cast<TCmService>(aMessage.Int0());

            TInt count( 0 );

            TInt time( 0 );

            TPckg<TInt> countPckg( count );

            TPckg<TInt> timePckg( time );

            iDbManager.GetTransferInfo(

                service, count, time );

            TRACE(Print(_L("[Cm Server]\t ECmGetTransferInfo \

            count = %d, time = %d"), count, time));

            aMessage.WriteL( 1, countPckg );

            aMessage.WriteL( 2, timePckg );

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetDataFields:

            {

            LOG(_L("[Cm Server]\t ECmGetDataFields request"));

            TInt len = aMessage.GetDesLength(0);

            if( len <= 0 )

                {

                LOG(_L("[Cm Server]\t ECmGetDataFields request \

                leaving with KErrArgument"));

                User::Leave( KErrArgument );

                }

            TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len));

            HBufC8* buffer = HBufC8::NewLC(len);

            TPtr8 ptr(buffer->Des());

            aMessage.ReadL(0, ptr);

            RDesReadStream stream;

            stream.Open(ptr);

            CleanupClosePushL(stream);

            iCollector->InternalizeL( stream );

            Server().SetCurrentAsyncMsg( aMessage );

            Server().ExecuteServiceL( ECmServiceGetFillFields,

                                      0,

                                      iCollector );

            CleanupStack::PopAndDestroy( 2 );

            break;

            }

        case ECmGetDataFieldSize:

            {

            LOG(_L("[Cm Server]\t ECmGetDataFieldSize request"));

            delete iDataBuffer;

            iDataBuffer = NULL;

            iDataBuffer = CBufFlat::NewL( KBufferExpandSize );

            RBufWriteStream propertyStream;

            propertyStream.Open( *iDataBuffer );

            CleanupClosePushL( propertyStream );

            CCmSqlPropertyCollector* propertyCollector =

                Server().PropertyCollector();

            if( !propertyCollector )

                {

                LOG(_L("[Cm Server]\t ECmGetDataFieldSize request \

                leaving with KErrArgument"));

                User::Leave( KErrArgument );

                }

            propertyCollector->ExternalizeL( propertyStream );

            TInt size = iDataBuffer->Size();

            TPckg<TInt> pckg( size );

            aMessage.WriteL(0, pckg );

            CleanupStack::PopAndDestroy( &propertyStream );

            TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size));

            aMessage.Complete( KErrNone );

            break;

            }

        case ECmGetDataBuffer:

            {

            TInt errCode = KErrNone;

            if ( !iDataBuffer )

                {

                LOG(_L("[Cm Server]\t ECmGetDataBuffer \

                databuffer doesn't exist"));

                errCode = KErrNotReady;

                }

            if (errCode == KErrNone )

                {

                aMessage.WriteL(0, iDataBuffer->Ptr(0));

                }

            aMessage.Complete( errCode );

            break;

            }

        case ECmGetFillRulesSize:

            {

            LOG(_L("[Cm Server]\t ECmGetFillRulesSize request"));

            delete iDataBuffer;

            iDataBuffer = NULL;

            iDataBuffer = CBufFlat::NewL( KBufferExpandSize );

            RBufWriteStream ruleStream;

            ruleStream.Open( *iDataBuffer );

            CleanupClosePushL( ruleStream );

            CCmFillRuleContainer* ruleContainer =

                Server().FillRuleContainerL();

            CleanupStack::PushL( ruleContainer );

            ruleContainer->ExternalizeL( ruleStream );

            CleanupStack::PopAndDestroy( ruleContainer );

            TInt size = iDataBuffer->Size();

            TPckg<TInt> pckg( size );

            aMessage.WriteL(0, pckg );

            CleanupStack::PopAndDestroy( &ruleStream );

            TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size));

            aMessage.Complete( KErrNone );

            LOG(_L("[Cm Server]\t ECmGetFillRulesSize request end"));

            break;

            }

        case ECmGetStoreItemsSize:

            {

            LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request"));

            TInt len = aMessage.GetDesLength( 0 );

            if( len <= 0 )

                {

                LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request \

                leaving with KErrArgument"));

                User::Leave( KErrArgument );

                }

            HBufC8* name = HBufC8::NewLC( len );

            TPtr8 ptr( name->Des() );

            aMessage.ReadL(0, ptr);

            iDbManager.PrepareQueryCmdL( EStoreFilesQuery );

            RPointerArray<CCmBaseListItem> items;

            CleanupClosePushL( items );

            iDbManager.QueryStoreFileListL(

                items,

                *name,

                ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice

            );

            TInt count = items.Count();

            TRACE(Print(_L("[Cm Server]\t store item array size is %d"),

                count));

            delete iDataBuffer;

            iDataBuffer = NULL;

            iDataBuffer = CBufFlat::NewL( KBufferExpandSize );

            RBufWriteStream ruleStream;

            ruleStream.Open( *iDataBuffer );

            CleanupClosePushL( ruleStream );

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

                {

                items[i]->ExternalizeL( ruleStream );

                }

            CleanupStack::PopAndDestroy( &ruleStream );

            items.ResetAndDestroy();

            CleanupStack::PopAndDestroy( &items );

            CleanupStack::PopAndDestroy( name );

            TInt size = iDataBuffer->Size();

            TPckg<TInt> sizePckg( size );

            aMessage.WriteL( 1, sizePckg );

            TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size));            

            TPckg<TInt> countPckg( count );

            aMessage.WriteL( 2, countPckg );

            TRACE(Print(_L("[Cm Server]\t item count is %d"), count));

            aMessage.Complete( KErrNone );

            LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request end"));

            break;

            }

        case ECmGetFillItemsSize:

            {

            LOG(_L("[Cm Server]\t ECmGetFillItemsSize request"));

            TInt len = aMessage.GetDesLength( 0 );

            if( len <= 0 )

                {

                LOG(_L("[Cm Server]\t ECmGetFillItemsSize request \

                leaving with KErrArgument"));

                User::Leave( KErrArgument );

                }

            HBufC8* name = HBufC8::NewLC( len );

            TPtr8 ptr( name->Des() );

            aMessage.ReadL(0, ptr);

            iDbManager.PrepareQueryCmdL( EFillFilesQuery );

            RPointerArray<CCmBaseListItem> items;

            CleanupClosePushL( items );

            iDbManager.QueryFillFileListL(

                items,

                *name,

                ECmFilled | ECmToBeFilled | ECmToBeShrinked | ECmLocalCopy

            );

            TInt count = items.Count();

            TRACE(Print(_L("[Cm Server]\t list item array size is %d"),

                count));