/*

* Copyright (c) 2005 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:  An implementation class for receiving Mediator events.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "MediatorEventConsumerBody.h"

#include    "MediatorServerClient.h"

#include    "Debug.h"

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

CMediatorEventConsumerBody::CMediatorEventConsumerBody( MMediatorEventObserver* aObserver )

    : CActive( EPriorityNormal ),

      iObserver( aObserver ), 

      iCategoryBuffer( iCategory ),

      iEventBuffer( iEvent ),

      iEventDataPtr( NULL, 0 ),

      iDestroyed ( NULL )

    {

    }

void CMediatorEventConsumerBody::ConstructL()

    {

    CActiveScheduler::Add( this );

    User::LeaveIfError( iMediatorServer.Connect() );

    ResetDataBufferL( KMaxEventData );  

    }

CMediatorEventConsumerBody* CMediatorEventConsumerBody::NewL(

                        MMediatorEventObserver* aObserver )

    {

    CMediatorEventConsumerBody* self = new( ELeave ) CMediatorEventConsumerBody( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CMediatorEventConsumerBody::~CMediatorEventConsumerBody()

    {

    Cancel();

    iMediatorServer.Close();

    delete iEventData;

    if ( iDestroyed ) // RunL is being executed

        {

        *iDestroyed = ETrue;

        }

    }

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

// CMediatorEventConsumerBody::RunL

//  

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

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

//

void CMediatorEventConsumerBody::RunL()

    {

    TRACE(Print(_L("[Mediator Server]\t CMediatorEventConsumerBody::RunL status %d\n"), iStatus.Int() ));

    if ( iObserver && ( iStatus >= KErrNone ) )

        {

        // Check the parameter data size. If bigger than expected, fetch it synchronously

        TInt dataSize = iStatus.Int();

        if ( dataSize > iEventDataPtr.MaxLength() )

            {

            // Reset data buffer for bigger size

            ResetDataBufferL( dataSize );

            // Fetch data from Mediator

            iMediatorServer.FetchParameterData( iEventDataPtr );

            }

        // Set the flag to the member variable that is updated by the destructor 

        // in case this instance is destroyed by observer callback.

        // Otherwise an attempt to manipulate member data after destruction will cause a panic.

        TBool destroyed = EFalse;

        iDestroyed = &destroyed;

        // must be trapped, so that leave won't cause access violation (iDestroyed pointing to a non-existing variable)

        TRAPD( err, iObserver->MediatorEventL( iCategory.iDomain,

                                               iCategory.iCategory, 

                                               iEvent.iEventId, 

                                               *iEventData ) );

        if ( err != KErrNone )

            {

            ERROR_TRACE(Print(_L("[Mediator] CMediatorEventConsumerBody::RunL: err=%d\n"), err ) );

            if ( !destroyed )

                {

                iDestroyed = NULL;

                }

            User::Leave( err );

            }

        if ( destroyed )

            {

            return; // instance destroyed in MediatorEventL, don't proceed to event receiving

            }

        iDestroyed = NULL; // set member variable to NULL, because local variable goes out of scope            

        }

    StartEventReceiving();

    }

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

// CMediatorEventConsumerBody::DoCancel

//  

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

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

//

void CMediatorEventConsumerBody::DoCancel()

    {

    LOG(_L("[Mediator Server]\t CMediatorEventConsumerBody::DoCancel\n")); 

    iMediatorServer.Cancel();    

    }

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

// CMediatorEventConsumerBody::SubscribeEventL

// Subscribe to event category

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

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

//

TInt CMediatorEventConsumerBody::SubscribeEvent( TUid aDomain,

                                                      TUid aCategory,

                                                      const REventList& aEvents )

    {

    LOG(_L("[Mediator Server]\t CMediatorEventConsumerBody::SubscribeEvent\n"));

    // Start to receive

    StartEventReceiving();

    // Subscribe

    return iMediatorServer.SubscribeEventList( aDomain, 

                                               aCategory,

                                               aEvents );

    }

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

// CMediatorEventConsumerBody::SubscribeEventL

// Subscribe to event

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

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

//

TInt CMediatorEventConsumerBody::SubscribeEvent( TUid aDomain,

                                                      TUid aCategory, 

                                                      TInt aEventId,

                                                      TVersion aVersion )

    {

    LOG(_L("[Mediator Server]\t CMediatorEventConsumerBody::SubscribeEvent\n"));

    __UHEAP_MARK;

    // Create a list to contain one event

    REventList eventList;

    TEvent event;

    event.iEventId = aEventId;

    event.iVersion = aVersion;

    TInt error = eventList.Append( event );

    if ( !error )

        {

        // Start to receive

        StartEventReceiving();

        // Subscribe eventlist

        error = iMediatorServer.SubscribeEventList( aDomain,

                                                    aCategory,

                                                    eventList );

        }

    else

        {

        ERROR_TRACE(Print(_L("[Mediator] CMediatorEventConsumerBody::SubscribeEvent: error=%d\n"), error ) );

        }

    // Clean up                                        

    eventList.Reset();

    __UHEAP_MARKEND;

    return error;

    }

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

// CMediatorEventConsumerBody::UnsubscribeEvent

// Unsubscibe an event category.

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

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

//

TInt CMediatorEventConsumerBody::UnsubscribeEvent( TUid aDomain,

                                                        TUid aCategory,

                                                        const REventList& aEvents )

    {

    LOG(_L("[Mediator Server]\t CMediatorEventConsumerBody::UnsubscribeEvent list\n"));

    return iMediatorServer.UnsubscribeEventList( aDomain, aCategory, aEvents );

    }

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

// CMediatorEventConsumerBody::UnsubscribeEvent

// Unsubscibe an event.

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

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

//

TInt CMediatorEventConsumerBody::UnsubscribeEvent( TUid aDomain,

                                                        TUid aCategory, 

                                                        TInt aEventId )

    {

    LOG(_L("[Mediator Server]\t CMediatorEventConsumerBody::UnsubscribeEvent\n"));

    __UHEAP_MARK;

    // Create a list to contain one event

    REventList eventList;

    TEvent event;

    event.iEventId = aEventId;

    TInt error = eventList.Append( event );

    if ( !error )

        {

        // Unsubscribe eventlist

        error = iMediatorServer.UnsubscribeEventList( aDomain,

                                                      aCategory,

                                                      eventList );

        }

    else

        {

        ERROR_TRACE(Print(_L("[Mediator] CMediatorEventConsumerBody::UnsubscribeEvent: error=%d\n"), error ) );

        }        

    // Clean up                                        

    eventList.Reset();

    __UHEAP_MARKEND;

    return error;

    }

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

// CMediatorEventConsumerBody::StartEventReceiving

// Starts to wait for events

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

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

//    

void CMediatorEventConsumerBody::StartEventReceiving()

    {

	if ( !IsActive() )

	    {

	    iMediatorServer.ReceiveEvents( iStatus, 

	                                   iCategoryBuffer, 

	                                   iEventBuffer, 

	                                   iEventDataPtr );

        SetActive();	                                   

	    }

    }

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

// CMediatorEventConsumerBody::ResetDataBufferL

// Starts to receive commands asynchronously

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

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

//    

void CMediatorEventConsumerBody::ResetDataBufferL( TInt aSize )

    {

    if ( iEventData )

        {

        delete iEventData;

        iEventData = NULL;

        }

    iEventData = HBufC8::NewL( aSize );

    iEventDataPtr.Set( iEventData->Des() );

    }

//  End of File