/*

* Copyright (c) 2008 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:  Content Manager server's client

*

*/

// INCLUDE FILES

#include    <s32mem.h>

#include    <badesca.h>

#include    "cmfillrulecontainer.h"

#include    "cmstorerulecontainer.h"

#include    "cmbaselistitem.h"

#include    "cmmediaserverfull.h"

#include    "cmsqlpropertyitem.h"

#include    "cmsqlpropertycontainer.h"

#include    "cmsqlpropertycollector.h"

#include    "cmdriveinfo.h"

#include    "cmactive.h"

#include    "msdebug.h"

// CONSTANTS

// Number of retries to start server

const TInt KServerRetries = 2;

// wizard executed state

const TInt KAppWizardExecuted = 1;

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

// StartServer

// Creates a new process for the server and starts it up.

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

//

static TInt StartServer()

    {

    LOG(_L("[Cm Server]\t StartServer begin"));

    TInt result( KErrNone );

    // create server - if one of this name does not already exist

    TFindServer findServer( KCmServerName );

    TFullName name;

    if ( findServer.Next( name ) != KErrNone ) // we don't exist already

        {

        TRequestStatus status( KRequestPending );

        RProcess server;

        // Create the server process

        result = server.Create( KCmServerExe, KNullDesC );

        if( result != KErrNone )

            {

            return result;

            }

        // Process created successfully

        server.Resume(); // start it going

        server.Rendezvous( status );

        // Wait until the completion of the server creation

        // server signals us when it's up

        User::WaitForRequest( status );

        if( status != KErrNone )

            {

            server.Close();

            return status.Int();

            }

        // Server created successfully

        server.Close(); // we can close the handle to server process now

        }

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

    return result;

    }

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

// RContentManager::RContentManager

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

//

EXPORT_C RContentManager::RContentManager()

    {

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

    iClientRequest = NULL;

    iTargetContainer = NULL;

    iBuffer = NULL;

    iAo = NULL;

    }

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

// RContentManager::Close

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

//

EXPORT_C TInt RContentManager::Close()

    {

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

    // Base call

    RSessionBase::Close();

    if ( iAo )

        {

        delete iAo; iAo = NULL;

        }

    if( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    return KErrNone;

    }

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

// RContentManager::Connect

// Starts and creates a session of Content Manager

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

//

EXPORT_C TInt RContentManager::Connect()

    {

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

    iCanceled = EFalse;

    TInt tryLoop( 0 );

    TInt errCode( KErrNone );

    for ( tryLoop = 0; tryLoop < KServerRetries; tryLoop++ )

        {

        errCode = CreateSession(KCmServerName,

            TVersion( KCmServerMajor, KCmServerMinor,

                    KCmServerBuild ) );

        //gives MessageSlots of -1

        //this uses global pool rather than local pool

        TRACE(Print(_L("[Cm Server]\t RContentManager::Connect New Session \

        created with status %d\n"), errCode));

        if( errCode == KErrNotSupported )

            {

            TRACE(Print(_L("[Cm Server]\t Version not supported!\n")));

            return errCode;

            }

        if ( errCode != KErrNotFound && errCode != KErrServerTerminated)

            {

            return errCode;

            }

        errCode = StartServer();

        TRACE(Print(_L("[Cm Server]\t RContentManager::Connect Start server \

        errCode %d\n"), errCode));

        if ( errCode != KErrNone && errCode != KErrAlreadyExists )

            {

            return errCode;

            }

        }

    return errCode;

    }

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

// RContentManager::OperationCompletedL

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

//

TInt RContentManager::OperationCompletedL( TInt aErr )

    {

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

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

    aErr = %d, iCanceled = %d\n"), aErr, iCanceled));

    if ( !aErr && !iCanceled )

        {

        // Items are changed so we don't want to keep old ones

        // Containers cannot be deleted because application

        // looses their address

        for ( TInt i = 0;

              i < (*iTargetContainer)->PropertyContainerCount();

              i++ )

            {

            CCmSqlPropertyContainer* container =

                            (*iTargetContainer)->PropertyContainer( i );

            for ( TInt j = 0; j < container->PropertyItemCount(); j++ )

                {

                container->DeletePropertyItem(j--);

                }

            }

        TInt size( 0 );

        TPckg<TInt> sizePckg( size );

        SendReceive( ECmGetDataFieldSize, TIpcArgs( &sizePckg ));

        if ( size > 0 )

            {

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

            TPtr8 bufferPointer = buffer->Des();

            SendReceive( ECmGetDataBuffer, TIpcArgs( &bufferPointer ) );

            RDesReadStream stream;

            stream.Open( bufferPointer );

            CleanupClosePushL( stream );

            // copy items to application side containers

            CopyItemsL( stream );

            CleanupStack::PopAndDestroy( 2, buffer );

            }

        }

    User::RequestComplete( iClientRequest, aErr );

    return KErrNone;

    }

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

// RContentManager::CopyItemsL

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

//

void RContentManager::CopyItemsL( RDesReadStream& aStream )

    {

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

    CCmSqlPropertyCollector* collector = CCmSqlPropertyCollector::NewLC();

    collector->InternalizeL( aStream );

    // append internalized items to containers

    for ( TInt k = 0; k < collector->PropertyContainerCount(); k++ )

        {

        CCmSqlPropertyContainer* container =

                                collector->PropertyContainer( k );

        CCmSqlPropertyContainer* targetContainer =

                                (*iTargetContainer)->PropertyContainer(k);

        for ( TInt l = 0; l < container->PropertyItemCount(); l++ )

            {

            // copy item

            // must be done so that we can destroy collector

            CCmSqlPropertyItem* item = new ( ELeave )

                            CCmSqlPropertyItem( *container->PropertyItem(l));

            CleanupStack::PushL( item );

            // add copied item

            targetContainer->AddPropertyItemL( item );

            CleanupStack::Pop( item );

            // delete original item

            container->DeletePropertyItem( l );

            // itemcount decreased so index must be updated also

            l--;

            }

        }

    CleanupStack::PopAndDestroy( collector );

    }

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

// RContentManager::Cancel

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

EXPORT_C void RContentManager::Cancel()

    {

    LOG(_L("[Cm Server]\t RContentManager::Cancel\n"));

    // iCanceled is set ETrue if user is closing the application

    // We don't want to cancel asynchronous process

    TRACE(Print(_L("[Cm Server]\t RContentManager::Cancel value is %d\n"),

        iCanceled));

    if ( !iCanceled )

        {

        SendReceive( ECmCancel, TIpcArgs() );

        }

    if ( iAo )

        {

        iAo->Deque();

        delete iAo; iAo = NULL;

        }

    LOG(_L("[Cm Server]\t RContentManager::Cancel end\n"));

    }

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

// RContentManager::ServerState

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

EXPORT_C TCmServerState RContentManager::ServerState() const

    {

    LOG(_L("[Cm Server]\t RContentManager::ServerState\n"));

    TCmServerState state;

    TPckg<TCmServerState> pckg( state );

    SendReceive( ECmGetServerState, TIpcArgs( &pckg ) );

    return state;

    }

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

// RContentManager::SetServiceState

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

EXPORT_C TInt RContentManager::SetServiceState( const TCmService aService,

                               const TCmServiceState aNewState )

    {

    LOG(_L("[Cm Server]\t RContentManager::SetServiceState\n"));

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

        aService, (TInt)aNewState ));

    SendReceive( ECmSetServiceState, TIpcArgs( aService, aNewState ) );

    return KErrNone;

    }

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

// RContentManager::ServiceState

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

EXPORT_C TCmServiceState RContentManager::ServiceState

    ( const TCmService aService ) const

    {

    LOG(_L("[Cm Server]\t RContentManager::ServiceState\n"));

    TCmServiceState state;

    TPckg<TCmServiceState> pckg( state );

    SendReceive( ECmGetServiceState, TIpcArgs( aService, &pckg ) );

    return state;

    }

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

// RContentManager::ExecuteService

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

EXPORT_C TInt RContentManager::ExecuteService( const TCmService aService,

                                               TRequestStatus& aStatus )

    {

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

    aService = %d\n"), aService ));

    SendReceive( ECmExecuteService, TIpcArgs( aService ), aStatus );

    return KErrNone;

    }

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

// RContentManager::GetItemCountsL

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

EXPORT_C TInt RContentManager::GetItemCountsL( const TCmService aService,

                                               const TDesC8& aListName,

                                               TInt& aCount,

                                               TInt64& aSize ) const

    {

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

    service = %d\n"), aService ));

    if ( aService != ECmServiceFill &&

         aService != ECmServiceStore )

        {

        LOG(_L("[Cm Server]\t RContentManager::ItemCount wrong argument\n"));

        User::Leave( KErrArgument );

        }

    TPckg<TInt> countPckg( aCount );

    TPckg<TInt64> sizePckg( aSize );

    SendReceive( ECmGetItemCount,

        TIpcArgs( &countPckg, &sizePckg, aService, &aListName ) );

    return KErrNone;

    }

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

// Get filled files size

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

EXPORT_C void RContentManager::GetFilledFilesSize( TInt64& aSize, const TInt aID ) const

    {

    TPckg<TInt64> sizePckg( aSize );

    SendReceive( ECmGetFilledFilesSize, TIpcArgs( &sizePckg, aID ) );

    }

// RContentManager::GetTransferInfo

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

EXPORT_C void RContentManager::GetTransferInfo( const TCmService aService,

                               TInt& aItemCount,

                               TInt& aTimeInSec ) const

    {

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

    service = %d\n"), aService ));

    TPckg<TInt> countPckg( aItemCount );

    TPckg<TInt> timePckg( aTimeInSec );

    SendReceive( ECmGetTransferInfo,

        TIpcArgs( aService, &countPckg, &timePckg ) );

    }

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

// RContentManager::GetFilteredMetadataL

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

EXPORT_C TInt RContentManager::GetFilteredMetadataL(

                            const TCmService aService,

                            CCmSqlPropertyCollector*& aCollector,

                            TRequestStatus& aStatus )

    {

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

    service = %d\n"), aService ));

    if ( aService != ECmServiceFill &&

         aService != ECmServiceStore )

        {

        LOG(_L("[Cm Server]\t RContentManager::GetFilteredMetadataL \

        wrong argument\n"));

        User::Leave( KErrArgument );

        }

    iCanceled = EFalse;

    if ( iAo )

        {

        delete iAo; iAo = NULL;

        }

    iAo = CCmActive::NewL( *this );

    iBuffer = CBufFlat::NewL( KKilo );

    RBufWriteStream stream;

    stream.Open( *iBuffer );

    CleanupClosePushL( stream );

    aCollector->ExternalizeL( stream );

    iBufferPointer.Set( iBuffer->Ptr(0) );

    SendReceive( ECmGetDataFields,

                 TIpcArgs( &iBufferPointer ),

                 iAo->iStatus);

    CleanupStack::PopAndDestroy(); // stream

    iAo->RunL();

    aStatus = KRequestPending;

    iTargetContainer = &aCollector;

    iClientRequest = &aStatus;

    return KErrNone;

    }

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

// RContentManager::DeleteMetadataL

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

EXPORT_C void RContentManager::UpdateFillListsL( TRequestStatus& aStatus )

    {

    LOG(_L("[Cm Server]\t RContentManager::UpdateFillListsL\n"));

    SendReceive( ECmUpdateFillLists, aStatus );

    }

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

// Deleting metadata harvested from unselected servers

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

EXPORT_C void RContentManager::DeleteMetadataL(

    TRequestStatus& aStatus )

    {

    LOG(_L("[Cm Server]\t RContentManager::DeleteMetadataL\n"));

    if( iBuffer )

        {

        delete iBuffer;

        iBuffer = NULL;

        }

    iBuffer = CBufFlat::NewL( KKilo );

    RBufWriteStream stream;

    stream.Open( *iBuffer );

    CleanupClosePushL( stream );

    iBufferPointer.Set( iBuffer->Ptr(0) );

    SendReceive( ECmDeleteMetadata,

                 TIpcArgs( &iBufferPointer ),

                 aStatus );

    CleanupStack::PopAndDestroy( &stream );

    }

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

// RContentManager::LastSyncTime

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

EXPORT_C TTime RContentManager::LastSyncTime() const

    {

    LOG(_L("[Cm Server]\t RContentManager::LastSyncTime\n"));

    TTime syncTime( 0 );

    TPckg<TTime> timePckg( syncTime );

    SendReceive( ECmGetSyncTime, TIpcArgs( &timePckg ) );

    return syncTime;

    }

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

// RContentManager::SetFillFileStatusesL

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

EXPORT_C void RContentManager::SetFillFileStatusesL(

            const RPointerArray<CCmBaseListItem>& aItems )

    {

    LOG(_L("[Cm Server]\t RContentManager::SetFillFileStatusesL\n"));

    CBufFlat* buffer = CBufFlat::NewL( KKilo );

    CleanupStack::PushL( buffer );

    RBufWriteStream stream;

    stream.Open( *buffer );

    CleanupClosePushL( stream );

    for ( TInt i = 0; i < aItems.Count(); i++ )

        {

        aItems[ i ]->ExternalizeL( stream );

        }

    TPtrC8 bufferPointer = buffer->Ptr(0);

    SendReceive( ECmSetFillFileStatuses,

                 TIpcArgs( &bufferPointer, aItems.Count() ) );

    CleanupStack::PopAndDestroy( 2, buffer );

    }

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

// RContentManager::AppWizardState

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