/*

* Copyright (c) 2002-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:  Handles client requests.

*

*/

// INCLUDE FILES

#include    "CSatClientServiceReq.h"

#include    "MSatUtils.h"

#include    "MSatSUiClientHandler.h"

#include    "EnginePanic.h"

#include    "SatLog.h"

_LIT( KTxtServer, "SatServer" );

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

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

// CSatClientServiceReq::CSatClientServiceReq

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSatClientServiceReq::CSatClientServiceReq(

    TSatServerRequest aRequest,

    TSatServerRequest aResponse,

    MSatCommand* aCommand,

    MSatUtils& aUtils ) :

    iHandledRequest( aRequest ),

    iHandledResponse( aResponse ),

    iResponseObserver( aCommand ),

    iUtils( aUtils )

    {

    LOG( SIMPLE, "SATENGINE: \

        CSatClientServiceReq::CSatClientServiceReq calling-exiting" )

    }

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

// CSatClientServiceReq::NewL

// Two-phased constructor.

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

//

CSatClientServiceReq* CSatClientServiceReq::NewL(

    TSatServerRequest aRequest,

    TSatServerRequest aResponse,

    MSatCommand* aCommand,

    MSatUtils& aUtils )

    {

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::NewL calling-exiting" )

    return new ( ELeave ) CSatClientServiceReq(

        aRequest, aResponse, aCommand, aUtils );

    }

// Destructor

CSatClientServiceReq::~CSatClientServiceReq()

    {

    LOG( SIMPLE,

        "SATENGINE: CSatClientServiceReq::~CSatClientServiceReq calling" )

    iResponseObserver = NULL;

    iCmdData = 0;

    iCmdRsp = 0;

    LOG( SIMPLE,

        "SATENGINE: CSatClientServiceReq::~CSatClientServiceReq exiting" )

    }

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

// CSatClientServiceReq::HandleCommand

// Handles the SIM command. If client has not yet requested service for this

// SIM command, command is stored for later use.

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

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

//

TBool CSatClientServiceReq::HandleCommand(

    TDesC8* aCmdData, // Data to be sent to client.

    TDes8* aCmdRsp, // Client is response is written to this.h

    TSatServerRequest aRequest ) // Command from SIM

    {

    LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleCommand calling" )

    __ASSERT_ALWAYS( iResponseObserver,

        PanicSatEngine( ESatEngineNullPointer ) );

    TBool handled( EFalse );

    // Handle the command here if the request op codes match.

    if ( iHandledRequest == aRequest )

        {

        LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleCommand \

             request op codes match" )

        // Store the descriptors

        iCmdData = aCmdData;

        iCmdRsp = aCmdRsp;

        handled = ETrue;

        // Is the client already waiting for the command

        if ( iRequestPending )

            {

            LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleCommand \

                 RequestPending" )

            // Request is served.

            iRequestPending = EFalse;

            SendDataToClient();

            }

        else

            {

            LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleCommand \

                 no RequestPending" )

            // Client request was not available, so command is waiting for

            // client request.

            iCmdPending = ETrue;

            }

        }

    LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleCommand exiting" )

    return handled;

    }

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

// CSatClientServiceReq::HandleRequest

// Handles the client's request.

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

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

//

TBool CSatClientServiceReq::HandleRequest(

    const RMessage2& aRequest ) // Request from client.

    {

    LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest calling" )

    TBool handled( EFalse );

    // Is the request handled here.

    const TInt request( aRequest.Function() );

    if ( request == iHandledRequest )

        {

        LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest \

             handle request" )

        handled = ETrue;

        iRequest = aRequest;

        // Is the command waiting for client.

        if ( iCmdPending )

            {

            LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest \

            iCmdPending" )

            iCmdPending = EFalse;

            SendDataToClient();

            }

        else

            {

            // Command has not yet arrived from SIM, so

            // wait for the command.

            iRequestPending = ETrue;

            }

        }

    // Is the response handled here.

    else if ( request == iHandledResponse )

        {

        LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest \

             handle response" )

        handled = ETrue;

        TRAPD( res, aRequest.ReadL( 0, *iCmdRsp ) );

        // Send the response further only if IPC succeeded.

        if ( KErrNone != res )

            {

            LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest \

            KErrNone != res" )

            iRequest.Panic( KTxtServer, ESatSBadDescriptor );

            }

        // Release client first, then handle the response

        aRequest.Complete( KErrNone );

        // Notify command that response is available.

        iResponseObserver->ClientResponse();

        }

    else

        {

        }

    LOG( DETAILED, "SATENGINE: CSatClientServiceReq::HandleRequest exiting" )

    return handled;

    }

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

// CSatClientServiceReq::SendDataToClient

// Writes the data to client address space and completes the iRequest.

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

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

//

void CSatClientServiceReq::SendDataToClient()

    {

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::SendDataToClient calling" )

    TRAPD( res,iRequest.WriteL( 0, *iCmdData ) );

    LOG2( SIMPLE, "SATENGINE: CSatClientServiceReq::SendDataToClient res: %d",

          res )

    if ( KErrNone != res )

        {

        iRequest.Panic( KTxtServer, ESatSBadDescriptor );

        }

    iRequest.Complete( KErrNone );

    // If UI is not launched by user, make sure UI is in foreground

    if ( !iUtils.SatUiHandler().UiLaunchedByUser() )

        {

        LOG( SIMPLE, 

        "SATENGINE: CSatClientServiceReq::SendDataToClient \

        EBringSatUiToForeGround" )

        iUtils.NotifyEvent( MSatUtils::EBringSatUiToForeGround );

        }

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::SendDataToClient exiting" )

    }

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

// CSatClientServiceReq::IsMyRequest

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

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

//

TBool CSatClientServiceReq::IsMyRequest( const TSatServerRequest aRequest )

    {

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::IsMyRequest calling" )

    TBool myRequest( EFalse );

    if ( iHandledRequest == aRequest )

        {

        LOG( SIMPLE,

            "SATENGINE: CSatClientServiceReq::IsMyRequest" )

        myRequest = ETrue;

        }

    LOG2( SIMPLE, "SATENGINE: CSatClientServiceReq::IsMyRequest exiting, \

          return: %d", myRequest )

    return myRequest;

    }

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

// CSatClientServiceReq::SetCommandHandler

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

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

//

void CSatClientServiceReq::SetCommandHandler( MSatCommand* aCommand )

    {

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::SetCommandHandler calling" )

    iResponseObserver = aCommand;

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::SetCommandHandler exiting" )

    }

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

// CSatClientServiceReq::Reset

// Resets member data

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

//

void CSatClientServiceReq::Reset()

    {

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::Reset calling" )

    // Check is request pending

    if ( !iRequestPending )

        {

        // Request not pending meaning that command is executing.

        // Send client response to prevent SIM to lock

        LOG( NORMAL, " Request is not pending" )

        // Notify command that response is available.

        iResponseObserver->ClientResponse();

        }

    // Clean data

    iCmdData = NULL;

    iCmdRsp = NULL;

    iCmdPending = EFalse;

    iRequestPending = EFalse;

    // We don't reset iResponseObserver

    LOG( SIMPLE, "SATENGINE: CSatClientServiceReq::Reset exiting" )

    }

//  End of File