/*

* Copyright (c) 2005-2007 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 issuing Mediator Service commands.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "MediatorCommandInitiatorBody.h"

#include    "MediatorServerClient.h"

#include    "Debug.h"

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

CMediatorCommandInitiatorBody::CMediatorCommandInitiatorBody(

                MMediatorCommandResponseObserver* aObserver )

    : CActive( EPriorityStandard ),

      iObserver( aObserver ),

      iCommandDataPtr( NULL, 0 ),

      iCategoryBuffer( iCategory ),

      iStatusBuffer( iResponseStatus ),

      iCommandBuffer( iCommand )

    {

    }

void CMediatorCommandInitiatorBody::ConstructL()

    {

    CActiveScheduler::Add( this );

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

    ResetDataBufferL( KMaxCommandData ); 

    }

CMediatorCommandInitiatorBody* CMediatorCommandInitiatorBody::NewL(

                MMediatorCommandResponseObserver* aObserver )

    {

    CMediatorCommandInitiatorBody* self 

                = new( ELeave ) CMediatorCommandInitiatorBody( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CMediatorCommandInitiatorBody::~CMediatorCommandInitiatorBody()

    {

    Cancel();

    iMediatorServer.Close();

    delete iCommandData;

    }

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

// CMediatorCommandInitiatorBody::DoCancel

//  

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

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

//

void CMediatorCommandInitiatorBody::DoCancel()

    {

    TRACE(Print(_L("[Mediator Server]\t CMediatorCommandInitiatorBody::DoCancel\n")));

    iMediatorServer.Cancel();  

    }

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

// CMediatorCommandInitiatorBody::IssueCommandL

//  

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

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

//

TInt CMediatorCommandInitiatorBody::IssueCommand( TUid aDomain,

                                                  TUid aCategory, 

                                                  TInt aCommandId,

                                                  TVersion aVersion, 

                                                  const TDesC8& aData )

    {

    TRACE(Print(_L("[Mediator Server]\t CMediatorCommandInitiatorBody::IssueCommandL\n"))); 

    // Check that we are not already active

    if ( IsActive() )

        {

        ERROR_LOG(_L("[Mediator] CMediatorCommandIntiatorBody::IssueCommand: IsActive returned KErrInUse\n"));

        return KErrInUse;

        }

    // Initiate response waiting before command, otherwise there will be a concurrency problem

    // with clients that issue response in command handler

    WaitForCommandResponse();

    // Send the command to Mediator                                 

    TInt status = iMediatorServer.IssueCommand( aDomain, 

                                                aCategory,

                                                aCommandId, 

                                                aVersion,

                                                aData );

    // Cancel command waiting request

    if ( status != KErrNone )

        {

        ERROR_TRACE(Print(_L("[Mediator] CMediatorCommandIntiatorBody::IssueCommand: status=%d\n"), status ) );

        // Cancel wait for response in server

        iMediatorServer.CancelCommand ( aDomain, aCategory, aCommandId );

        Cancel();

        }

    return status;

    }

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

// CMediatorCommandInitiatorBody::CancelCommand

//  

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

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

//

void CMediatorCommandInitiatorBody::CancelCommand( TUid aDomain, 

                                                        TUid aCategory, 

                                                        TInt aCommandId )

    {

    TRACE(Print(_L("[Mediator Server]\t CMediatorCommandInitiatorBody::CancelCommand\n")));

    // Send the cancellation

    iMediatorServer.CancelCommand( aDomain, aCategory, aCommandId );

    Cancel(); // cancel also the pending request, so that subsequent commands will be served 

    }

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

// CMediatorCommandInitiatorBody::RunL

//  

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

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

//

void CMediatorCommandInitiatorBody::RunL()

    {

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

    // in case of error, no callbacks

    if ( iStatus.Int() >= 0 && iObserver )

        {

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

        TInt dataSize = iStatus.Int();

        if ( dataSize > iCommandDataPtr.MaxLength() )

            {

            // Reset data buffer for bigger size

            ResetDataBufferL( dataSize );

            // Fetch data from Mediator

            iMediatorServer.FetchParameterData( iCommandDataPtr );

            }

        iObserver->CommandResponseL( iCategory.iDomain,

                                     iCategory.iCategory,

                                     iCommand.iCommandId, 

                                     iResponseStatus,

                                     *iCommandData );                                  

        }

    }

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

// CMediatorCommandInitiatorBody::WaitForCommandResponse

//  

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

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

//

void CMediatorCommandInitiatorBody::WaitForCommandResponse()

    {

    // To be sure no duplicate requests are raised

    if ( IsActive() )

        {

        return;

        }

    iMediatorServer.WaitForCommandResponse( iStatus,

                                            iCategoryBuffer,

                                            iCommandBuffer,

                                            iCommandDataPtr,

                                            iStatusBuffer );

    SetActive();                                            

    }

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

// CMediatorCommandResponder::ResetDataBufferL

// Starts to receive commands asynchronously

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

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

//    

void CMediatorCommandInitiatorBody::ResetDataBufferL( TInt aSize )

    {

    if ( iCommandData )

        {

        delete iCommandData;

        iCommandData = NULL;

        }

    iCommandData = HBufC8::NewL( aSize );

    iCommandDataPtr.Set( iCommandData->Des() );

    }

//  End of File