/*
* Copyright (c) 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:  Client that communicate with CatalogsEnginePCClientFrontEnd
*
*/


#include "catalogspcconnectivityclient.h"
#include "catalogspcconnectivitydefines.h"


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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
RCatalogsPCConnectivityClient::RCatalogsPCConnectivityClient()
    {
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
RCatalogsPCConnectivityClient::~RCatalogsPCConnectivityClient()
    {
    }

// ---------------------------------------------------------------------------
// Start server and create session with server
// ---------------------------------------------------------------------------
//
TInt RCatalogsPCConnectivityClient::Connect()
    {
    TInt err = StartServer();
        
    if ( err == KErrNone )
        {
        err = CreateSession( 
            KCatalogsPCConnectivityServerName,
            Version(), 
            KCatalogsPCConnectivityDefaultMessageSlots );
        }
    return err;
    }

// ---------------------------------------------------------------------------
// Close session (After session is closed will server be closed too)
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::Close()
    {
    RHandleBase::Close();
    }

// ---------------------------------------------------------------------------
// Give MIME types supported by this Module
// ---------------------------------------------------------------------------
//
RPointerArray<TDataType> RCatalogsPCConnectivityClient::
SupportedMimeTypesL()
    {
    RPointerArray<TDataType> supportedMIMEs;
    TBool isThereMore = ETrue;
    TPckgBuf<TBool> pckgIsThereMore;
    TDataType* tempMIME = 0;
    TPckgBuf<TDataType> pckgMIME;
    
    while( isThereMore )
        {
        User::LeaveIfError( SendReceive( 
                ECatalogsPCConnectivitySupportedMimeTypes, 
                TIpcArgs( &pckgMIME, &pckgIsThereMore ) ) );
        isThereMore = pckgIsThereMore();
        tempMIME = new( ELeave ) TDataType( pckgMIME() );
        User::LeaveIfError( supportedMIMEs.Append( tempMIME ) );
        }

    return supportedMIMEs;
    }

// ---------------------------------------------------------------------------
// Data package from CatalogsPCConnectivityPlugin
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::PutDataL( 
    const TDataType& aMimeType, const CBufFlat& aData )
    {
    TInt size = aData.Size();
    
    RBuf8 desData;
    desData.CreateL( size );
    desData.CleanupClosePushL();
    aData.Read( 0, desData, size );
    TPckgBuf<TDataType> pckgMIME( aMimeType );

    User::LeaveIfError( SendReceive( 
            ECatalogsPCConnectivityPutData, 
            TIpcArgs( &pckgMIME, &desData, size ) ) );

    CleanupStack::Pop(); //desData
    desData.Close();
    }

// ---------------------------------------------------------------------------
// Data request from CatalogsPCConnectivityPlugin
// First ask the size from server, then give correct size CBufFlat
// ---------------------------------------------------------------------------
//
void RCatalogsPCConnectivityClient::GetDataL( 
    TDataType& aMimeType, CBufFlat& aData )
    {
    TPckgBuf<TInt> pckgSize;
    TPckgBuf<TDataType> pckgMIME;
    
    User::LeaveIfError( SendReceive( 
            ECatalogsPCConnectivityGetSize, 
            TIpcArgs( &pckgMIME, &pckgSize ) ) );
    
    TInt size = pckgSize();
    aMimeType = pckgMIME();
    
    RBuf8 desData;
    desData.CreateL( size );
    desData.CleanupClosePushL();
    
    User::LeaveIfError( SendReceive( 
            ECatalogsPCConnectivityGetData, 
            TIpcArgs( &desData ) ) );
    
    aData.Reset();
    aData.ExpandL( 0, size );
    aData.Write( 0, desData, size );        
            
    CleanupStack::Pop(); //desData
    desData.Close();
    }

// ---------------------------------------------------------------------------
// Return version number
// ---------------------------------------------------------------------------
//
TVersion RCatalogsPCConnectivityClient::Version() const
    {
    return( TVersion( KCatalogsPCConnectivityMajorVersionNumber,
            KCatalogsPCConnectivityMinorVersionNumber,
            KCatalogsPCConnectivityBuildVersionNumber ) );
    }

// ---------------------------------------------------------------------------
// Start server if it isn't running already
// ---------------------------------------------------------------------------
//
TInt RCatalogsPCConnectivityClient::StartServer()
    {
    // Check if the server is already running
    TFindServer findServer( KCatalogsPCConnectivityServerName );
    TFullName name;

    TInt result = findServer.Next( name );
    if ( result == KErrNone )
        {
        // Server is running
        return KErrNone;
        }

    // Create a semaphore so we can wait while the server starts
    RSemaphore semaphore;
    result = semaphore.CreateGlobal( 
    	KCatalogsPCConnectivityServerSemaphoreName, 0 );
    if ( result != KErrNone )
        {
        return result;
        }

    // Create new Engine service process 
    result = CreateServerProcess();
    if ( result != KErrNone )
        {
        semaphore.Close();
        return result;
        }

    // Wait while the server starts
    semaphore.Wait();

    // Semaphore has been signaled, close and return
    semaphore.Close();

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Create server process
// ---------------------------------------------------------------------------
//
TInt RCatalogsPCConnectivityClient::CreateServerProcess()
    {

    RProcess server;

    TInt result = server.Create( 
        KCatalogsPCConnectivityServerFilename, KNullDesC );
    if ( result != KErrNone )
        {
        return result;
        }
    
    // Resume server thread and close handle
    server.Resume();
    server.Close();  

    return KErrNone;
    }


//end