/*
* Copyright (c) 2002 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:  Storage main client
*
*/


// INCLUDE FILES
#include "RPEngStorageClient.h"
#include <eikdll.h>
#include <f32file.h>

#include "PEngServerStarter.h"
#include "PEngStorageServerCommon.h"
#include "TPEngStorageServerMessages.h"

// PEC Engine internal constants
#include "PEngPresenceEngineConsts2.h"
#include "PEngInternalGlobalConsts.h"

#include "PresenceDebugPrint.h"


// CONSTANTS
// each session can have several sub-session, while only one sub-session
// is using asynchronous requests, 20 slots shall be enough to cover
const TUint KMessageSlotCount = 20;


// MACROS
#define RETURN_IF_NOT_CONNECTED()\
    if(!iConnected)\
        {\
        return KErrDisconnected;\
        }

#define RETURN_IF_NULL( desBuff )\
    if ( !desBuff )\
        {\
        return KErrNoMemory;\
        }

// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// RPEngStorageClient::RPEngStorageClient
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
RPEngStorageClient::RPEngStorageClient()
    {
    }

// Destructor
RPEngStorageClient::~RPEngStorageClient()
    {
    }

// =============================================================================
// =============Function of the client for Connection managing =================
// =============================================================================

// -----------------------------------------------------------------------------
// RPEngStorageClient::Connect
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::Connect()
    {
    PENG_DP_TXT( "RPEngStorageClient::Connect()" );

    //Connects this client to the server.
    //Launches new server process if one not yet running.
    TInt err = PEngServerStarter::ConnectServer( *this,
                                                 KStorageServerName,
                                                 Version(),
                                                 KMessageSlotCount,
                                                 KStorageServerExe );

    iConnected = ( err == KErrNone );
    return err;
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::Close
// -----------------------------------------------------------------------------
//
void RPEngStorageClient::Close()
    {
    PENG_DP_TXT( "RPEngStorageClient::Close()" );

    // all requests from this session are canceled on the server side
    RSessionBase::Close();
    iConnected = EFalse;
    }

// =============================================================================
// ============= New Function of the client  ===================================
// =============================================================================

// -----------------------------------------------------------------------------
// RPEngStorageClient::SessionSlotState()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::SessionSlotState(
    const TDesC8& aSessionName,
    HBufC8*& aSessionState,
    TInt aInitSize )
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    messArgs.Set( KMessageSlot0, &aSessionName );
    aSessionState = HBufC8::New( aInitSize );
    RETURN_IF_NULL( aSessionState );
    TPtr8 sessState ( aSessionState->Des() );
    messArgs.Set( KMessageSlot1, &sessState );
    TInt err( SendReceive( EMainSessGetSessionState, messArgs ) );
    // if error is positive, then buffer was not big enough
    if ( err > KErrNone )
        {
        // realloc buffer, looks complicated, but safe, avoiding realloc
        delete aSessionState;
        aSessionState = NULL;
        aSessionState = HBufC8::New( err );
        RETURN_IF_NULL( aSessionState );
        sessState.Set( aSessionState->Des() );
        messArgs.Set( KMessageSlot1, &sessState );
        err = SendReceive( EMainSessGetSessionState, messArgs );
        }
    // if there was error erase buffer
    if ( err < KErrNone )
        {
        delete aSessionState;
        aSessionState = NULL;
        }
    return err;
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::AllSessionSlotsStates()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::AllSessionSlotsStates(
    HBufC8*& aSessionSlotsBuffer,
    TInt aInitSize )
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    aSessionSlotsBuffer = HBufC8::New( aInitSize );
    RETURN_IF_NULL( aSessionSlotsBuffer );
    TPtr8 sessStates ( aSessionSlotsBuffer->Des() );
    messArgs.Set( KMessageSlot0, &sessStates );
    TInt err( SendReceive( EMainSessGetAllSessionStates, messArgs ) );
    // if error is positive, then buffer was not big enough
    if ( err > KErrNone )
        {
        // realloc buffer, looks complicated, but safe, avoiding realloc
        delete aSessionSlotsBuffer;
        aSessionSlotsBuffer = NULL;
        aSessionSlotsBuffer = HBufC8::New( err );
        RETURN_IF_NULL( aSessionSlotsBuffer );
        sessStates.Set( aSessionSlotsBuffer->Des() );
        messArgs.Set( KMessageSlot1, &sessStates );
        err = SendReceive( EMainSessGetAllSessionStates, messArgs );
        }
    // if there was error erase buffer
    if ( err < KErrNone )
        {
        delete aSessionSlotsBuffer;
        aSessionSlotsBuffer = NULL;
        }
    return err;
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::ListenGlobalEvents()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::ListenGlobalEvents()
    {
    RETURN_IF_NOT_CONNECTED();
    return SendReceive( EMainSessListenGlobalEvents );
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::ReloadGlobalEventListener()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::ReloadGlobalEventListener(
    TDes8& aGlobalEventBuffer,
    TRequestStatus& aStatus )
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    messArgs.Set( KMessageSlot0, EMainSessListenGlobalEvents );
    messArgs.Set( KMessageSlot1, &aGlobalEventBuffer );
    SendReceive( EMainSessReloadAsynchronousScout, messArgs, aStatus );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::StopEventListening()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::StopEventListening()
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    messArgs.Set( KMessageSlot0, EMainSessListenGlobalEvents );
    return SendReceive( EMainSessCancelRequest, messArgs );
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::CreateSessionFolder()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::CreateSessionFolder(
    const TDesC8& aSessionSlot,
    const TDesC16& aApplicationId )
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    messArgs.Set( KMessageSlot0, &aSessionSlot );
    messArgs.Set( KMessageSlot1, &aApplicationId );

    return SendReceive( EMainSessCreateSessionFolder, messArgs );
    }

// -----------------------------------------------------------------------------
// RPEngStorageClient::RemoveSessionFolder()
// -----------------------------------------------------------------------------
//
TInt RPEngStorageClient::RemoveSessionFolder(
    const TDesC8& aSessionSlot,
    const TDesC16& aApplicationId )
    {
    RETURN_IF_NOT_CONNECTED();
    TIpcArgs messArgs;
    messArgs.Set( KMessageSlot0, &aSessionSlot );
    messArgs.Set( KMessageSlot1, &aApplicationId );
    return SendReceive( EMainSessRemoveSessionFolder, messArgs );
    }


// -----------------------------------------------------------------------------
// RPEngStorageClient::Version()
// -----------------------------------------------------------------------------
//
TVersion RPEngStorageClient::Version() const
    {
    return( TVersion( KClientVersionMajor,
                      KClientVersionMinor,
                      KClientVersionBuild ) );
    }

//  End of File