/*

* 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 API implementation for the Mediator Server

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32std.h>

#include <s32mem.h>

#include "MediatorServerClient.h"

#include "MediatorCommon.h"

#include "Debug.h"

// CONSTANTS

const TInt KServerRetries = 2;

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

RMediatorServer::RMediatorServer()

	{

	}

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

// RMediatorServer::Connect

// Creates a new client-server -session with MediatorServer. Starts it up if not

// started already.

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

//

TInt RMediatorServer::Connect()

	{

	// Check that there's no connection existing already

	if ( Handle() )

	    {

	    return KErrAlreadyExists;

	    }

    TInt tryLoop = 0;

    TInt error = 0;

    // Try to create session to server. If server is not started, try to start it.

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

        {

        error = CreateSession( KMediatorServerName, Version() );   

        TRACE(Print(_L("[Mediator Server]\t Session created with status %d\n"), error));

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

            {

            if ( error != KErrNone )

                {

                ERROR_TRACE(Print(_L("[Mediator] RMediatorServer::Connect(ln%d): error=%d\n"), __LINE__, error ) );    

                }

            return error;

            }

        error = StartServer();

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

            {

            ERROR_TRACE(Print(_L("[Mediator] RMediatorServer::Connect(ln%d): error=%d\n"), __LINE__, error ) );

            return error;

            }

        }

    return error;

	}

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

// StartServer

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

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

//

TInt RMediatorServer::StartServer()

    {

	TInt result( KErrNone );

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

	TFindProcess findServerProcess( KMediatorServerProcessName );

	TFullName name;

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

		{

		TRequestStatus status( KRequestPending );

		RProcess server;

		// Create the server process

		result = server.Create( KMediatorServerExe, KNullDesC );		

		if( result != KErrNone )

			{

			ERROR_TRACE(Print(_L("[Mediator] RMediatorServer::StartServer: result=%d\n"), result ) );

			return result;

			}

		// Process created successfully

		server.Rendezvous( status );

		server.Resume(); // start it going

		// Wait until the completion of the server creation

		// server signals us when it's up

		User::WaitForRequest( status );

		if( status != KErrNone )

			{

            ERROR_TRACE(Print(_L("[Mediator] RMediatorServer::StartServer: status=%d\n"), status.Int() ) );

			server.Close();

			return status.Int();

			}

		// Server created successfully

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

		}

    return result;

    }

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

// RMediatorServer::Close

//  

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

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

//

void RMediatorServer::Close()

	{

	// Base call

	RSessionBase::Close(); 

	}

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

// RMediatorServer::Version

//  

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

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

//

TVersion RMediatorServer::Version(void) const

	{

	return( TVersion( KMediatorServerMajor, 

	                  KMediatorServerMinor, 

	                  KMediatorServerBuild ));

	}

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

// RMediatorServer::Cancel

// Cancels ongoing command in Mediator

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

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

//

void RMediatorServer::Cancel( )

    {

    LOG(_L("[Mediator Server]\t RMediatorServer::Cancel\n")); 

    //  Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    // Send the command (ignore return value)                                

    SendReceive( ECancelAll, TIpcArgs() );

    }

// ============================ REGISTRATION COMMANDS ==========================

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

// RMediatorServer::RegisterEventL

// Registers event list to MediatorServer 

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

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

//

TInt RMediatorServer::RegisterEventList( TUid aDomain,  

                                         TUid aCategory,

                                         const REventList& aEvents )

    {

    LOG(_L("[Mediator Server]\t RMediatorServer::RegisterEventL list\n")); 

    //  Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    TInt status = KErrNone;

    // Check that there's something to register                                           

    if ( aEvents.Count() > 0 )

        { 

        // Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create event array write pointer

        TInt arraySize = ( sizeof(MediatorService::TEvent) ) * aEvents.Count();

        TPtr8 arrayPtr( (TUint8*)&aEvents[0], arraySize, arraySize );

        // Send the command to server

        status =  SendReceive( ERegisterEventList, 

                               TIpcArgs( &categoryBuffer, 

                                         &arrayPtr ) );                                        

        }

    return status;

    }

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

// RMediatorServer::RegisterCommandListL

// Registers command list to MediatorServer 

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

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

//

TInt RMediatorServer::RegisterCommandList( TUid aDomain,  

                                           TUid aCategory,

                                           const RCommandList& aCommands )

    {

    LOG(_L("[Mediator Server]\t RMediatorServer::RegisterEventL list\n")); 

    //  Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));                                        

    TInt status = KErrNone;

    // Check that there's something to register                                           

    if ( aCommands.Count() )

        {

        // Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create command array write pointer

        TInt arraySize = ( sizeof(MediatorService::TCommand) ) * aCommands.Count();

        TPtr8 arrayPtr( (TUint8*)&aCommands[0], arraySize, arraySize );

        // Send the command to server

        status =  SendReceive( ERegisterCommandList, 

                               TIpcArgs( &categoryBuffer, 

                                         &arrayPtr ) );   

        }

    return status;

    }

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

// RMediatorServer::UnregisterEventL

// Unregisters event list.

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

//

TInt RMediatorServer::UnregisterEventList( TUid aDomain,  

                                           TUid aCategory,

                                           const REventList& aEvents )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::UnregisterEventListL\n")));  

    // Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    TInt status = KErrNone;

    // Check that there's something to unregister                                           

    if ( aEvents.Count() )

        {

        // Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create event array write pointer

        TInt arraySize = ( sizeof(MediatorService::TEvent) ) * aEvents.Count();

        TPtr8 arrayPtr( (TUint8*)&aEvents[0], arraySize, arraySize );

        // Send the command to server

        status = SendReceive( EUnregisterEventList, 

                                         TIpcArgs( &categoryBuffer, 

                                                   &arrayPtr ) );                                                 

        }

    return status;

    }

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

// RMediatorServer::UnregisterCommandL

// Unregisters command list.

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

//

TInt RMediatorServer::UnregisterCommandList( TUid aDomain, 

                                             TUid aCategory,

                                             const RCommandList& aCommands )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::UnregisterCommandList\n")));  

    // Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    TInt status = KErrNone;

    // Check that there's something to unregister                                           

    if ( aCommands.Count() )

        {

        /// Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create command array write pointer

        TInt arraySize = ( sizeof(MediatorService::TCommand) ) * aCommands.Count();

        TPtr8 arrayPtr( (TUint8*)&aCommands[0], arraySize, arraySize );

        // Send the command to server

        status = SendReceive( EUnregisterCommandList, 

                              TIpcArgs( &categoryBuffer, 

                                        &arrayPtr ) );

        }

    return status;

    }

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

// RMediatorServer::RaiseEventL

// Raise event to Mediator Server.

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

//

TInt RMediatorServer::RaiseEvent( TUid aDomain,  

                                  TUid aCategory,

                                  TInt aEventId,

                                  TVersion aVersion,

                                  const TDesC8& aData )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::RaiseEvent\n")));  

    // Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    // Create a structures for event data

    TMediatorCategory category;

    category.iDomain = aDomain;

    category.iCategory = aCategory;

    TMediatorCategoryBuffer categoryBuffer( category );

    TEvent event;

    event.iEventId = aEventId;

    event.iVersion = aVersion;

    TEventBuffer eventBuffer( event );

    // Send the command to server

    return SendReceive( ERaiseEvent, 

                          TIpcArgs( &categoryBuffer, 

                                    &eventBuffer, 

                                    &aData ) );

    }

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

// RMediatorServer::SubscribeEvent

// Subscribes a list of events

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

//

TInt RMediatorServer::SubscribeEventList( TUid aDomain,  

                                          TUid aCategory,

                                          const REventList& aEvents )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::SubscribeEventList\n")));  

    // Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    TInt status = KErrNone;

    // Check that there's something to unregister                                           

    if ( aEvents.Count() )

        {

        // Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create event array write pointer

        TInt arraySize = ( sizeof(MediatorService::TEvent) ) * aEvents.Count();

        TPtr8 arrayPtr( (TUint8*)&aEvents[0], arraySize, arraySize );

        // Send the command to server

        status = SendReceive( ESubscribeEventList, 

                               TIpcArgs( &categoryBuffer, 

                                         &arrayPtr ) );                                              

        }

    return status;                                   

    }

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

// RMediatorServer::UnsubscribeEventListL

// Unsubscribes a list of events.

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

//

TInt RMediatorServer::UnsubscribeEventList( TUid aDomain,  

                                            TUid aCategory,

                                            const REventList& aEvents )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::UnsubscribeEventList\n")));  

    // Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    TInt status = KErrNone;

    // Check that there's something to unregister                                           

    if ( aEvents.Count() )

        {

        // Fill category

        TMediatorCategory category;

        category.iDomain = aDomain;

        category.iCategory = aCategory;

        TMediatorCategoryBuffer categoryBuffer( category );

        // Create event array write pointer

        TInt arraySize = ( sizeof(MediatorService::TEvent) ) * aEvents.Count();

        TPtr8 arrayPtr( (TUint8*)&aEvents[0], arraySize, arraySize );

        // Send the command to server

        status = SendReceive( EUnsubscribeEventList, 

                               TIpcArgs( &categoryBuffer, 

                                         &arrayPtr ) );                                              

        }

    return status;      

    }

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

// RMediatorServer::IssueCommand

// Synchronous function to send command request to Mediator Server

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

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

//

TInt RMediatorServer::IssueCommand( TUid aDomain,

                                    TUid aCategory, 

                                    TInt aCommandId,

                                    TVersion aVersion, 

                                    const TDesC8& aData )

    {

    TRACE(Print(_L("[Mediator Server]\t RMediatorServer::IssueCommand\n"))); 

    //  Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    // Fill category

    TMediatorCategory category;

    category.iDomain = aDomain;

    category.iCategory = aCategory;

    TMediatorCategoryBuffer categoryBuffer( category );

    // And command

    TCommand command;

    command.iCommandId = aCommandId;

    command.iVersion = aVersion;

    //Time out is initiatilized to 0 as its not used on the server side.  

    command.iTimeout = 0;

    TCommandBuffer commandBuffer( command );

    // Send the command                                 

    return SendReceive( EIssueCommand, 

                        TIpcArgs( &categoryBuffer, 

                                  &commandBuffer, 

                                  &aData ) );

    }

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

// RMediatorServer::IssueResponse

// Synchronous function to send command request to Mediator Server

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

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

//

TInt RMediatorServer::IssueResponse( TUid aDomain, 

                                     TUid aCategory, 

                                     TInt aCommandId,

                                     TInt aStatus,

                                     const TDesC8& aData )

    {

    LOG(_L("[Mediator Server]\t RMediatorServer::IssueResponse\n")); 

    //  Check that session is open.

    __ASSERT_DEBUG( Handle(), User::Panic( KMediatorServerPanic, 

                                           EMediatorClientNoSessionActive ));

    // Fill category

    TMediatorCategory category;

    category.iDomain = aDomain;

    category.iCategory = aCategory;

    TMediatorCategoryBuffer categoryBuffer( category );

    // And command

    TCommand command;

    command.iCommandId = aCommandId;

    TCommandBuffer commandBuffer( command );

    // Status

    TPckgBuf<TInt> statusBuffer( aStatus );

    // Send the command                                 

    return SendReceive( EIssueResponse, 

                        TIpcArgs( &categoryBuffer, 

                                  &commandBuffer, 

                                  &statusBuffer,

                                  &aData ) );

    }

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

// RMediatorServer::CancelCommand