/*

* Copyright (c) 2005-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:  Session implementation class for Mediator Server

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <s32mem.h>

#include    "MediatorServerSession.h"

#include    "MediatorCommon.h"

#include    "MediatorServer.h"

#include    "MediatorServiceDefs.h"

#include    "mediatorqueitem.h"

#include    "MediatorDebug.h"

#include    "Debug.h"

using namespace MediatorService;

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

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

// CMediatorServerSession::CMediatorServerSession

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

//

CMediatorServerSession::CMediatorServerSession() :iNotificationsRegistered( EFalse ),

                                                  iNotificationQueue( _FOFF(CMediatorQueItem,iSlink) )

	{

	}

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

// CMediatorServerSession::NewL

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

//

CMediatorServerSession* CMediatorServerSession::NewL()

	{

	LOG(_L("[Mediator Server]\t CMediatorServerSession::NewL"));

	return new( ELeave ) CMediatorServerSession();

	}

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

// CMediatorServerSession::~CMediatorServerSession

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

//    

CMediatorServerSession::~CMediatorServerSession()

	{

	LOG(_L("[Mediator Server]\t CMediatorServerSession::~CMediatorServerSession"));

    // cancel all asynchronous waiting procedures

    CancelAll( KErrCancel );

    // cancel pending commands

    Server().CommandHandler().CancelCommands( this, this );

	// Unregister all subscriptions

	// Get handler

    CMediatorServerObjectHandler& objectHandler = Server().ObjectHandler();

    objectHandler.ClearRegistrations( this, this, this );

    iEventServiceList.ResetAndDestroy();

	iCommandServiceList.ResetAndDestroy();

	if ( iDataBuffer )

	    {

	    delete iDataBuffer;

	    }

	CleanNotificationQueue();

	}

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

// CMediatorServerSession::CleanNotificationQueue

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

// 

void CMediatorServerSession::CleanNotificationQueue()

    {

    LOG(_L("[Mediator Server]\t CMediatorServerSession::CleanNotificationQueue"));

    // release memory allocated to notification queue items

    TSglQueIter<CMediatorQueItem> iter( iNotificationQueue );

    CMediatorQueItem* item;

    while ( ( item = iter++ ) != NULL)

        {

        iNotificationQueue.Remove( *item );

        delete item;

        }

    }

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

// CMediatorServerSession::Server

// Returns a reference to server

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

//

CMediatorServer& CMediatorServerSession::Server()

    {

    return *static_cast<CMediatorServer*>(const_cast<CServer2*>(CSession2::Server()));

    }

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

// CMediatorServerSession::ServiceL

// Implements CSession2 -derived ServiceL -method.

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

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

//

void CMediatorServerSession::ServiceL(const RMessage2& aMessage)

	{

	LOG(_L("[Mediator Server]\t CMediatorServerSession::ServiceL"));

	// If ServiceL leaves, default implementation in server framework

	// completes the RMessage2 with the leave code.

	DispatchMessageL( aMessage );

	}

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

// CMediatorServerSession::ServiceError

// Implements CSession2 -derived ServiceError -method.

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

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

//

void CMediatorServerSession::ServiceError(const RMessage2& aMessage,TInt aError)

    {

    ERROR_TRACE(Print(_L("[Mediator] CMediatorServerSession::ServiceError: opcode=%d, aError=%d\n"), aMessage.Function(), aError ));

    RMediatorDebug::LogError(aMessage, aError);

    CSession2::ServiceError(aMessage, aError);

    }

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

// CMediatorServerSession::ReadCategoryL

// 

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

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

//   

TMediatorCategory CMediatorServerSession::ReadCategoryL( 

                                        const RMessage2& aMessage,

                                        const TInt aMessageSlot )

    {

    TMediatorCategoryBuffer categoryBuffer;

    aMessage.ReadL( aMessageSlot, categoryBuffer );

    TMediatorCategory category = categoryBuffer();

    return category;

    }

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

// CMediatorServerSession::WriteCategoryL

// 

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

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

//   

void CMediatorServerSession::WriteCategoryL( TUid aDomain,

                                             TUid aCategory,

                                             const RMessage2& aMessage,

                                             const TInt aMessageSlot  )

    {

    TMediatorCategory category;

    category.iDomain = aDomain;

    category.iCategory = aCategory;

    TMediatorCategoryRetBuffer categoryBuffer( category );

    aMessage.WriteL( aMessageSlot, categoryBuffer );

    }

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

// CMediatorServerSession::WriteEventL

// 

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

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

//       

void CMediatorServerSession::WriteEventL( TInt aEventId,

                                          const RMessage2& aMessage,

                                          const TInt aMessageSlot )

    {

    MediatorService::TEvent event;

    event.iEventId = aEventId;

    TEventRetBuffer buffer( event );

    aMessage.WriteL( aMessageSlot, buffer );

    }

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

// CMediatorServerSession::WriteCommandL

// 

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

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

//       

void CMediatorServerSession::WriteCommandL( TInt aCommandId,

                                            TVersion aVersion,

                                            const RMessage2& aMessage,

                                            const TInt aMessageSlot )

    {

    MediatorService::TCommand command;

    command.iCommandId  = aCommandId;

    command.iVersion    = aVersion;

    TCommandRetBuffer buffer( command );

    aMessage.WriteL( aMessageSlot, buffer );

    }

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

// CMediatorServerSession::ReadEventListL

// 

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

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

// 

REventList CMediatorServerSession::ReadEventListL( const RMessage2& aMessage,

                                                   const TInt aMessageSlot )

    {

     // Read event list information from Message

    REventList eventList;

    CleanupClosePushL( eventList );

    // Create input pointer for data

    TInt size = aMessage.GetDesMaxLength( aMessageSlot );

    TInt count = size / ( sizeof(MediatorService::TEvent) );

    if ( count <= 0 )

        {

        User::Leave( KErrArgument );

        }

    for ( TInt index = 0; index < count; index ++ )

        {

        TEvent event;

        eventList.AppendL( event );

        }

    TPtr8 arrayPtr( (TUint8*)&eventList[0], size );

    // Read data from message

    aMessage.ReadL( aMessageSlot, arrayPtr );

    CleanupStack::Pop( &eventList );

    return eventList;

    }

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

// CMediatorServerSession::EventListFitsToClientMemory

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

// 

TBool CMediatorServerSession::EventListFitsToClientMemory( const REventList& aEvents,

                                                           const RMessage2& aMessage,

                                                           const TInt aMessageSlot )

    {

    TBool retval( ETrue );

    if ( aEvents.Count() > 0 )

        {

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

        // Check that there's enough space before writing the answer

        TInt space( aMessage.GetDesMaxLength( aMessageSlot ) ); 

        retval = ( arraySize <= space );

        }

    return retval;

    }

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

// CMediatorServerSession::CommandListFitsToClientMemory

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

// 

TBool CMediatorServerSession::CommandListFitsToClientMemory( const RCommandList& aCommands,

                                                             const RMessage2& aMessage,

                                                             const TInt aMessageSlot )

    {

    TBool retval( ETrue );

    if ( aCommands.Count() > 0 )

        {

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

        // Check that there's enough space before writing the answer

        TInt space( aMessage.GetDesMaxLength( aMessageSlot ) ); 

        retval = ( arraySize <= space );

        }

    return retval;

    }

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

// CMediatorServerSession::WriteEventListL

// 

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

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

//   

void CMediatorServerSession::WriteEventListL( const REventList& aEvents,

                                              const RMessage2& aMessage,

                                              const TInt aMessageSlot )

    {

    if ( aEvents.Count() > 0 )

        {

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

        TInt space( aMessage.GetDesMaxLength( aMessageSlot ) );

        // the method assumes that there's enought space in client memory to accommadate the events

        __ASSERT_DEBUG( space >= arraySize, User::Invariant() );

        if ( arraySize > space )

            {

            arraySize = space; // ensure that we don't overflow client buffer in any circumstances

            }

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

        aMessage.WriteL( aMessageSlot, arrayPtr );

        }

    }

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

// CMediatorServerSession::ReadCommandListL

// 

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

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

// 

RCommandList CMediatorServerSession::ReadCommandListL( const RMessage2& aMessage,

                                                       const TInt aMessageSlot )

    {

     // Read command list information from Message

    RCommandList commandList;

    CleanupClosePushL( commandList );

    // Create input pointer for data

    TInt size = aMessage.GetDesMaxLength( aMessageSlot );

    TInt count = size / ( sizeof(MediatorService::TCommand) );

    for ( TInt index = 0; index < count; index ++ )

        {

        TCommand command;

        commandList.AppendL( command );

        }

    TPtr8 arrayPtr( (TUint8*)&commandList[0], size );

    // Read data from message

    aMessage.ReadL( aMessageSlot, arrayPtr );

    CleanupStack::Pop( &commandList );

    return commandList;

    }

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

// CMediatorServerSession::WriteCommandListL

// 

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

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

//   

void CMediatorServerSession::WriteCommandListL( const RCommandList& aCommands,

                                                const RMessage2& aMessage,

                                                const TInt aMessageSlot )

    {

    // Write the command list back to client

    if ( ( aCommands.Count() > 0 ) )

        {

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

        // Check that there's enough space before writing the answer

        TInt space( aMessage.GetDesMaxLength( aMessageSlot ) ); 

        // this method assumes that there's enough space in client side

        __ASSERT_DEBUG( arraySize <= space, User::Invariant() );

        if ( arraySize > space ) // overflow prevention

            {

            arraySize = space;

            }

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

        aMessage.WriteL( aMessageSlot, arrayPtr );

        }

    }

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

// CMediatorServerSession::ReadDataL

// 

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

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

//     

HBufC8* CMediatorServerSession::ReadDataLC( const RMessage2& aMessage,

                                            const TInt aMessageSlot )

    {

     // Then read parameter data from slot 2

    TInt dataSize = aMessage.GetDesLength( aMessageSlot );

    if ( dataSize < 0 )

        {

        User::Leave( KErrArgument );

        }

    HBufC8* data = HBufC8::NewLC( dataSize );

    TPtr8 ptr( data->Des() );

	aMessage.ReadL( aMessageSlot, ptr );

	return data;

    }

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

// CMediatorServerSession::WriteDataL

// 

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

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

//   

void CMediatorServerSession::WriteDataL( const TDesC8& aData,

                                         const RMessage2& aMessage,

                                         const TInt aMessageSlot )

    {

    // Read max data length

    TInt space = aMessage.GetDesMaxLength( aMessageSlot );

    if ( space >= aData.Length() )

        {

        aMessage.WriteL( aMessageSlot, aData );

        }

    else    // Not enough space to write

        {

        // Store the data to temporary buffer --> it is fetched from client side

        // synchronously

        if ( iDataBuffer )

            {

            delete iDataBuffer;

            iDataBuffer = NULL;

            }

        iDataBuffer = aData.AllocL();

        }

    }

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

// CMediatorServerSession::ReadEventL

// 

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

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

//       

MediatorService::TEvent CMediatorServerSession::ReadEventL( 

                                    const RMessage2& aMessage,

                                    const TInt aMessageSlot )

    {

    TEventBuffer eventBuffer;

    aMessage.ReadL( aMessageSlot, eventBuffer );

    return eventBuffer();

    }

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

// CMediatorServerSession::ReadCommandL

// 

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

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

//       

MediatorService::TCommand CMediatorServerSession::ReadCommandL( 

                                    const RMessage2& aMessage,

                                    const TInt aMessageSlot )

    {

    TCommandBuffer commandBuffer;

    aMessage.ReadL( aMessageSlot, commandBuffer );

    return commandBuffer();

    }

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

// CMediatorServerSession::DispatchMessageL

// Dispatches message according to its opcode

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

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

//

void CMediatorServerSession::DispatchMessageL( const RMessage2 &aMessage )

    {

	LOG(_L("[Mediator Server]\t CMediatorServerSession::DispatchMessageL"));

	RMediatorDebug::Log(aMessage, *this);

    switch ( aMessage.Function() )

        {

        case ERegisterEventList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: ERegisterEventList"));

            RegisterEventListL( aMessage );

            break;

            }    

        case ERegisterCommandList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: ERegisterCommand"));

            RegisterCommandListL( aMessage );

            break;

            }

        case EUnregisterEventList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: EUnregisterEventList"));

            UnregisterEventListL( aMessage );

            break;

            }

         case EUnregisterCommandList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: EUnregisterCommandList"));

            UnregisterCommandListL( aMessage );

            break;

            }

        case ESubscribeEventList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: ESubscribeEvent"));

            SubscribeEventListL( aMessage );

            break;

            }

        case EUnsubscribeEventList:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: EUnsubscribeEvent"));

            UnsubscribeEventListL( aMessage );

            break;

            }

        case ERaiseEvent:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: ERaiseEvent"));

            RaiseEventL( aMessage );

            break;

            }

        case EIssueCommand:

            {

            LOG(_L("[Mediator Server]\t DispatchMessageL: IssueCommandL"));

            IssueCommandL( aMessage );

            break;

            }  

         case ECancelCommand: