/*

* Copyright (c) 2004-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:  Sub Session Messenger.

*                The stub version of this file can be found from file

*                CPhSrvSubSessionMessengerStub.cpp

*

*/

// INCLUDE FILES

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

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

// CPhSrvSubSessionMessenger::CPhSrvSubSessionMessenger

// 

// Constructor.

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

//

CPhSrvSubSessionMessenger::CPhSrvSubSessionMessenger( 

    CPhSrvSession& aSession )

:   CPhSrvSubSessionBase( aSession, EPhSrvSubSessionTypeMessenger )

    {

    }

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

// CPhSrvSubSessionMessenger::~CPhSrvSubSessionMessenger

// 

// Destructor.

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

//

CPhSrvSubSessionMessenger::~CPhSrvSubSessionMessenger()

    {

    Clean();

    }

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

// CPhSrvSubSessionMessenger::NewL

// 

// Two-phased constructor.

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

//

CPhSrvSubSessionBase* CPhSrvSubSessionMessenger::NewL(

    CPhSrvSession& aSession )

    {

    // Just to make sure that the negotiator will exist.

    aSession.PhoneServer().MessengerNegotiatorL();

    CPhSrvSubSessionBase* self = 

        new( ELeave ) CPhSrvSubSessionMessenger( aSession );

    return self;

    }

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

// CPhSrvSubSessionMessenger::PhSrvMessageDecoderCanProcessMessage

// 

// Framework function. Returns ETrue for the op codes that

// this subsession can handle.

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

//

TBool CPhSrvSubSessionMessenger::PhSrvMessageDecoderCanProcessMessage( 

    TInt aFunction )

    {

    switch( aFunction )

        {

        case EPhoneServerMessengerSubSessionOpen:

        case EPhoneServerMessengerSubSessionClose:

        case EPhoneServerMessengerSubSessionConstruct:

        case EPhoneServerMessengerSubSessionReceive:

        case EPhoneServerMessengerSubSessionSend:

        case EPhoneServerMessengerSubSessionSkip:

        case EPhoneServerMessengerSubSessionCancel:

            return ETrue;

        default:

            return EFalse;

        }

    }

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

// CPhSrvSubSessionMessenger::PhSrvMessageProcessorHandleMessageL

// 

// Framework function. Handle any op-codes here.

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

//

void CPhSrvSubSessionMessenger::PhSrvMessageProcessorHandleMessageL( 

    const RMessage2& aMessage )

    {

    TBool permissionStatus ( EFalse );

    // Check needed capabilities    

    TBool hasCapWriteDeviceData( EFalse );                  

    hasCapWriteDeviceData = aMessage.HasCapability( ECapabilityWriteDeviceData );            

    switch( aMessage.Function() )

        {

        case EPhoneServerMessengerSubSessionClose:

            CmdSubSessionClose( aMessage );

            permissionStatus = ETrue;

            break;

        case EPhoneServerMessengerSubSessionConstruct:

            CmdSubSessionMessengerConstructL( aMessage );

            permissionStatus = ETrue;

            break;

        case EPhoneServerMessengerSubSessionReceive:

            if ( hasCapWriteDeviceData )

                {  

                CmdSubSessionMessengerReceive( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerMessengerSubSessionSend:

            if ( hasCapWriteDeviceData )

                {  

                CmdSubSessionMessengerSend( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerMessengerSubSessionSkip:

            if ( hasCapWriteDeviceData )

                {  

                CmdSubSessionMessengerSkip( aMessage );

                permissionStatus = ETrue;

                }

            break;

        case EPhoneServerMessengerSubSessionCancel:

            if ( hasCapWriteDeviceData )

                {  

                CmdSubSessionMessengerCancel( aMessage );

                permissionStatus = ETrue;

                }

            break;

        default:

            PhoneSession().PanicClient(

                aMessage,

                EPhCltServerInitiatedPanicInvalidRequest );

            break;

        }

    // If caps are not ok

    if ( !permissionStatus )

        {        

        aMessage.Complete( KErrPermissionDenied );

        }         

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionClose

// 

// Close the sub-session.

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionClose( 

    const RMessage2& aMessage )

    {

    Clean();

    PhoneSession().CloseSubSession( aMessage );

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionMessengerConstructL

// 

// 

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionMessengerConstructL( 

    const RMessage2& aMessage )

    {

    TPhCltMessengerParameters parameters;

    // Check the Construct parameters.

    TPckg< TPhCltMessengerParameters > recParPckg( 

        parameters );

    Read(

        aMessage,

        0,

        recParPckg );

    // Ask the messenger negotiator to reserve all needed space

    // for this subsession.

    MPhSrvMessengerNegotiator& messengerNegotiator = GetMessengerNegotiator();

    messengerNegotiator.NegotiatorRequestConstructL( 

        *this,

        parameters,

        aMessage );

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionMessengerReceive

// 

// 

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionMessengerReceive( 

    const RMessage2& aMessage )

    {

    TPhCltMessengerParameters parameters;

    // Check the Receive parameters.

    TPckg< TPhCltMessengerParameters > recParPckg( 

        parameters );

    Read(

        aMessage,

        0,

        recParPckg );

    // This is Receive request.

    parameters.iMessengerCommand = EPhCltMesCommandReceive;

    // Ask the messenger negotiator to handle this request.

    ForwardRequest( 

        *this,

        parameters,

        aMessage );

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionMessengerSend

// 

// 

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionMessengerSend( 

    const RMessage2& aMessage )

    {

    TPhCltMessengerParameters parameters;

    // Check the Send parameters.

    TPckg< TPhCltMessengerParameters > sendParPckg( 

        parameters );

    Read(

        aMessage,

        0,

        sendParPckg );

    // This is Send request.

    parameters.iMessengerCommand = EPhCltMesCommandSend;

    // Ask the messenger negotiator to handle this request.

    ForwardRequest( 

        *this,

        parameters,

        aMessage );

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionMessengerSkip

// 

// 

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionMessengerSkip( 

    const RMessage2& aMessage )

    {

    TPhCltMessengerParameters parameters;

    // This is Skip request.

    parameters.iMessengerCommand = EPhCltMesCommandSkip;

    // Ask the messenger negotiator to handle this request.

    ForwardRequest( 

        *this,

        parameters,

        aMessage );

    }

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

// CPhSrvSubSessionMessenger::CmdSubSessionMessengerCancel

// 

// Handle command handler client's cancel request.

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

//

void CPhSrvSubSessionMessenger::CmdSubSessionMessengerCancel( 

    const RMessage2& aMessage )

    {

    TInt returnValue = KErrArgument;

    TPhCltMessengerParameters parameters;

    // Check the Cancel parameters.

    TPckg< TPhCltMessengerParameters > recParPckg( 

        parameters );

    Read(

        aMessage,

        0,

        recParPckg );

    TPhCltMessengerRequest request = parameters.iCancelRequest;

    TPhCltMessengerCommand mesCommand = EPhCltMesCommandUnknown;

    if ( request == EPhCltMesRequestReceive)

        {

        mesCommand = EPhCltMesCommandReceive;

        }

    else if ( request == EPhCltMesRequestSend )

        {

        mesCommand = EPhCltMesCommandSend;

        }

    // Perform cancel only if that was valid request.

    if ( mesCommand != EPhCltMesCommandUnknown )

        {

        // Ask the messenger negotiator to cancel the pending request

        // for this subsession.

        MPhSrvMessengerNegotiator& messengerNegotiator = 

            GetMessengerNegotiator();

        messengerNegotiator.NegotiatorRequestCancel( *this, mesCommand );

        returnValue = KErrNone;

        }

    aMessage.Complete( returnValue );

    }

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

// CPhSrvSubSessionMessenger::GetMessengerNegotiator

// 

// Return the messenger negotiator.

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

//

MPhSrvMessengerNegotiator& CPhSrvSubSessionMessenger::GetMessengerNegotiator()

    {

    // Messenger negotiator created already in NewL.

    return PhoneSession().PhoneServer().MessengerNegotiator();

    }

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

// CPhSrvSubSessionMessenger::ForwardRequest

// 

// Forward request to negotiator.

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

//

void CPhSrvSubSessionMessenger::ForwardRequest(

    CPhSrvSubSessionBase& aSubSession,

    const TPhCltMessengerParameters& aParameters,

    const RMessage2& aMessage )

    {

    // Ask the messenger negotiator to handle this request.

    MPhSrvMessengerNegotiator& messengerNegotiator = GetMessengerNegotiator();

    messengerNegotiator.NegotiatorRequest( 

        aSubSession,

        aParameters,

        aMessage );

    }

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

// CPhSrvSubSessionMessenger::Clean

// 

// Clean the negotiator side.

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

//

void CPhSrvSubSessionMessenger::Clean()

    {

    // Ask the messenger negotiator to release all reserved space

    // for this subsession.

    MPhSrvMessengerNegotiator& messengerNegotiator = GetMessengerNegotiator();

    messengerNegotiator.NegotiatorRequestDelete( *this );

    }

// End of File