/*

 * 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:

 *

 */

#include "cautils.h"

#include "caclientsession.h"

#include "caclientsubsession.h"

#include "caclientproxy.h"

#include "cainnerentry.h"

#include "cainnerquery.h"

#include "caidsarray.h"

#include "caentriesarray.h"

#include "caclientnotifierproxy.h"

const TInt KInnerEntryExpandSize = 1024;

// Function prototypes

static TInt StartServer();

static TInt CreateServerProcess();

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

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

//

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

RCaClientSession::RCaClientSession() :

    RSessionBase()

    {

    // No implementation required

    }

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

//

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

TInt RCaClientSession::Connect()

    {

    TInt error =

            CreateSession( KCaSrvName, Version() );

    if( error == KErrNone )

        {

        ShareAuto();

        }

    return error;

    }

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

//

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

TInt RCaClientSession::StartServer()

    {

    return ::StartServer();

    }

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

//

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

void RCaClientSession::Close()

    {

    RSessionBase::Close();

    }

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

//

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

TVersion RCaClientSession::Version() const

    {

    return ( TVersion( KCaMajorVersion, KCaMinorVersion, KCaBuild ) );

    }

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

//

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

void RCaClientSession::GetListL( const CCaInnerQuery& aQuery,

        RCaEntriesArray& aResult )

    {

    TInt resultSize(0);

    TInt error = GetSizeL( aQuery, EContentArsenalGetList_GetSize,

        resultSize );

    if( error == KErrNone )

        {

        error = GetResultL( resultSize, EContentArsenalGetList_GetData,

                aResult );

        }

    User::LeaveIfError( error );

    }

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

//

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

void RCaClientSession::GetEntryIdsL( const CCaInnerQuery& aQuery,

        RCaIdsArray& aResult )

    {

    TInt resultSize( 0 );

    TInt error = GetSizeL( aQuery, EContentArsenalGetIds_GetSize,

            resultSize );

    if( error == KErrNone )

        {

        error = GetResultL( resultSize, EContentArsenalGetIds_GetData,

                aResult );

        }

    User::LeaveIfError( error );

    }

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

//

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

TInt RCaClientSession::GetSizeL( const CCaInnerQuery& aQuery,

        const TCaServerRequests aServerRequest, TInt& aResultSize )

    {

    TIpcArgs args;

    HBufC8* serializedQuery = MenuUtils::MarshalDataL( aQuery, 128 );

    CleanupStack::PushL( serializedQuery );

    args.Set( KInputPosition1, serializedQuery );

    TPckg<TInt> sizeDes( aResultSize );

    args.Set( KOutputPosition, &sizeDes );

    TInt error = SendReceive( aServerRequest, args );

    CleanupStack::PopAndDestroy( serializedQuery );

    return error;

    }

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

//

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

void RCaClientSession::AddL( CCaInnerEntry& aEntry )

    {

    TIpcArgs args;

    HBufC8* serializedEntry = MenuUtils::MarshalDataL( aEntry, KInnerEntryExpandSize );

    CleanupStack::PushL( serializedEntry );

    args.Set( KInputPosition1, serializedEntry );

    TInt id( 0 );

    TPckg<TInt> resultId( id );

    args.Set( KOutputPosition, &resultId );

    TInt error = SendReceive( EContentArsenalAdd, args );

    User::LeaveIfError( error );

    aEntry.SetId( id );

    CleanupStack::PopAndDestroy( serializedEntry );

    }

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

//

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

void RCaClientSession::RemoveL( const RCaIdsArray& aEntries )

    {

    TIpcArgs args;

    HBufC8* inbuf = aEntries.MarshalDataLC();

    args.Set( KInputPosition1, inbuf );

    User::LeaveIfError( SendReceive( EContentArsenalRemove, args ) );

    CleanupStack::PopAndDestroy( inbuf );

    }

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

//

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

void RCaClientSession::OrganizeL( const RCaIdsArray& aEntries,

        TCaOperationParams aParams )

    {

    TIpcArgs args;

    HBufC8* inbuf = aEntries.MarshalDataLC();

    args.Set( KInputPosition1, inbuf );

    TPckg<TCaOperationParams> data( aParams );

    args.Set( KInputPosition2, &data );

    User::LeaveIfError( SendReceive( EContentArsenalOrganize, args ) );

    CleanupStack::PopAndDestroy( inbuf );

    }

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

//

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

void RCaClientSession::TouchL( const CCaInnerEntry& aEntry )

    {

    TIpcArgs args;

    HBufC8* serializedEntry = MenuUtils::MarshalDataL( aEntry, KInnerEntryExpandSize );

    CleanupStack::PushL( serializedEntry );

    args.Set( KInputPosition1, serializedEntry );

    User::LeaveIfError( SendReceive( EContentArsenalTouch, args ) );

    CleanupStack::PopAndDestroy( serializedEntry );

    }

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

//

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

void RCaClientSession::CustomSortL( const RCaIdsArray& aEntries,

        const TInt aGroupId )

    {

    TIpcArgs args;

    HBufC8* inbuf = aEntries.MarshalDataLC();

    args.Set( KInputPosition1, inbuf );

    TPckg<TInt> groupId( aGroupId );

    args.Set( KInputPosition2, &groupId );

    User::LeaveIfError( SendReceive( EContentArsenalCustomSort, args ) );

    CleanupStack::PopAndDestroy( inbuf );

    }

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

//

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

template<typename SerializableObject>

TInt RCaClientSession::GetResultL( TInt aSize, TCaServerRequests aRequest,

        SerializableObject& aObject )

    {

    TIpcArgs args;

    RBuf8 outbuf;

    outbuf.CleanupClosePushL();

    outbuf.CreateL( aSize );

    args.Set( KOutputPosition, &outbuf );

    TInt error = SendReceive( aRequest, args );

    if( error == KErrNone )

        {

        RDesReadStream stream( outbuf );

        CleanupClosePushL( stream );

        aObject.InternalizeL( stream );

        CleanupStack::PopAndDestroy( &stream );

        }

    CleanupStack::PopAndDestroy( &outbuf );

    return error;

    }

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

// StartServer

// Static function to start the server.

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

//

static TInt StartServer()

    {

    TInt result;

    TFindServer findServer( KCaSrvName );

    TFullName name;

    result = findServer.Next( name );

    if( result != KErrNone )

        {

        // Server not running

        result = CreateServerProcess();

        }

    return result;

    }

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

// CreateServerProcess

// Static function to create the server process.

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

//

static TInt CreateServerProcess()

    {

    TInt err( KErrNone );

    RProcess server;

    err = server.Create( KCaSrvExe, KNullDesC, EOwnerThread );

    if( !err )

        {

        TRequestStatus status;

        server.Rendezvous( status );

        if( status != KRequestPending )

            {

            server.Kill( 0 ); // Abort startup.

            }

        else

            {

            server.Resume(); // Logon OK - start the server.

            }

        User::WaitForRequest( status ); // Wait for start or death.

        // We can't use the 'exit reason' if the server panicked as this

        // is the panic 'reason' and may be '0' which cannot be distinguished

        // from KErrNone.

        err = ( server.ExitType() == EExitPanic ) ? KErrGeneral

                : status.Int();

        server.Close();

        }

    return err;

    }