/*

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

*

*/

// INCLUDE FILES

#include "CPhSrvMessengerObject.h"

#include "CPhSrvSubSessionBase.h"

#include "CPhSrvSession.h" // Phone server session.

#include "PhSrvDebugInfo.h"

// CONSTANTS

// Null ID.

const TUint KPhSrvNullId = 0;

// The minimum Default message size.

const TInt KPhSrvMinDefSize = 1;

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

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

// CPhSrvMessengerObject::CPhSrvMessengerObject

// 

// Constructor.

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

//

CPhSrvMessengerObject::CPhSrvMessengerObject( 

    CPhSrvSubSessionBase& aSubSession )

:   iSubSession( aSubSession )

    {

    }

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

// CPhSrvMessengerObject::~CPhSrvMessengerObject

// 

// Destructor.

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

//

CPhSrvMessengerObject::~CPhSrvMessengerObject()

    {

    }

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

// CPhSrvMessengerObject::ConstructL

// 

// Symbian 2nd phase constructor can leave.

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

//

void CPhSrvMessengerObject::ConstructL(

    const TPhCltMessengerParameters& aParameters )

    {

    TInt size = aParameters.iDefaultMessageSize;

    if( size < KPhSrvMinDefSize )

        {

        // Default message size must be at least KPhSrvMinDefSize.

        User::Leave( KErrArgument );

        }

    iParameters.iCategoryUid = aParameters.iCategoryUid;

    iParameters.iDefaultMessageSize = size;

    }

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

// CPhSrvMessengerObject::NewLC

// 

// Static Symbian OS two-phase constructor. Return an instance

// and leave it on the cleanup stack.

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

//

CPhSrvMessengerObject* CPhSrvMessengerObject::NewLC(  

    CPhSrvSubSessionBase& aSubSession,

    const TPhCltMessengerParameters& aParameters )

    {

    CPhSrvMessengerObject* self = new( ELeave ) CPhSrvMessengerObject( 

        aSubSession );

    CleanupStack::PushL( self );

    self->ConstructL( aParameters );

    return self;

    }

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

// CPhSrvMessengerObject::InformOfMessengerRequest

// 

// Complete a client request which will indicate the result

// of attempting to perform a request.

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

//

void CPhSrvMessengerObject::InformOfMessengerRequest( 

    const TPhCltPhoneResults aResultOfAttemptingRequest,

    const TPhCltMessengerCommand aRequest )

    {

    // Complete the client's pending request, indicating 

    // the result of the messenger request attempt.

    if ( aRequest == EPhCltMesCommandSend )

        {

        // Send command.

        if ( iParameters.iSendDataValid )

            {

            iParameters.iSendStatus.Complete( aResultOfAttemptingRequest );

            iParameters.iSendDataValid = EFalse;

            }

        }

    else if ( aRequest == EPhCltMesCommandReceive )

        {

        // Receive command.

        if ( iParameters.iReceiveDataValid )

            {

            iParameters.iReceiveMessage.Complete( aResultOfAttemptingRequest );

            iParameters.iReceiveDataValid = EFalse;

            }

        }

    else

        {

        // Should never happen!

        }

    }

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

// CPhSrvMessengerObject::SubSessionHandle

// 

// Return the handle of the subsession that initiated the

// original messenger request.

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

//

TInt CPhSrvMessengerObject::SubSessionHandle() const

    {

    return iSubSession.SubSessionUniqueHandle();

    }

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

// CPhSrvMessengerObject::SetActive

// 

// Set the request active.

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

//

void CPhSrvMessengerObject::SetActive( 

    const TPhCltMessengerParameters& aParameters,

    const RMessage2& aMessage,

    const TUint aSentDataId )

    {

    TPhCltMessengerCommand request = aParameters.iMessengerCommand;

    switch( request )

        {

        case EPhCltMesCommandSend:

            {

            // Set the Send data parameters.

            iParameters.iSendStatus = aMessage;

            iParameters.iSendDataValid = ETrue;

            iParameters.iSentDataId = aSentDataId;

            iParameters.iSendPayloadLength = aParameters.iSendPayloadLength;

            break;

            }

        case EPhCltMesCommandReceive:

            {

            // Set the Receive parameters.

            iParameters.iReceiveMessage = aMessage;

            iParameters.iReceiveBufferMaxSize = 

                aParameters.iReceiveBufferMaxSize;

            iParameters.iReceiveDataValid = ETrue;

            // Receive called, so Skip can not be active.

            iParameters.iSkipNextMessage = EFalse;

            iParameters.iSkippedSentDataId = KPhSrvNullId;

            break;

            }

        case EPhCltMesCommandSkip:

            {

            iParameters.iSkipNextMessage = ETrue;

            break;

            }

        default:

            // Should never happen!

            break;

        }

    }

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

// CPhSrvMessengerObject::IsRequestActive

// 

// Check if there is already active request.

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

//

TBool CPhSrvMessengerObject::IsRequestActive( 

    const TPhCltMessengerCommand aRequest ) const

    {

    TBool isRequestActive = EFalse;

    switch( aRequest )

        {

        case EPhCltMesCommandSend:

            {

            isRequestActive = iParameters.iSendDataValid;

            break;

            }

        case EPhCltMesCommandReceive:

            {

            isRequestActive = iParameters.iReceiveDataValid;

            break;

            }

        case EPhCltMesCommandSkip:

            {

            isRequestActive = iParameters.iSkipNextMessage;

            break;

            }

        default:

            // Should never happen!

            break;

        }

    return isRequestActive;

    }

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

// CPhSrvMessengerObject::IsReadyToReceive

// 

// Check whether this object is ready to receive or not.

// If Receive is active but the length of the buffer 

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

//

TBool CPhSrvMessengerObject::IsReadyToReceive( 

    const TDesC8& aSentMessage,

    const TUint aSentDataId )

    {

    TBool ret = EFalse;

    const TInt sendDataLength = aSentMessage.Length();

    ret = IsMessageSkipped( aSentDataId );

      // If the message is not skipped, handle it here.

    if ( !ret )

        {

        // If receive data is valid, then we can be ready to receive.

        if( iParameters.iReceiveDataValid )

            {

            // If the sent message does not fit to receive buffer, then complete

            // Receive to indicate that bigger buffer is needed.

            if ( sendDataLength > 

                 iParameters.iReceiveBufferMaxSize )

                {

                CompleteReceive( aSentMessage, aSentDataId );

                }

            else

                {

                // Object can receive the sent message.

                ret = ETrue;

                }

            }

        }

    return ret;

    }

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

// CPhSrvMessengerObject::CompleteReceive

// 

// Complete the receive request.

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

//

TInt CPhSrvMessengerObject::CompleteReceive(

    const TDesC8& aSentMessage,

    const TUint aSentDataId )

    {

    _DPRINT( 4, "PhSrv.MesObj.CompleteReceive START" );   // debug print

    TBool ret = IsMessageSkipped( aSentDataId );

    TInt err = KErrNotReady;

    // If message is skipped, then we do not complete the request.

    if( ret )

        {

        err = KErrNone;

        }

    // If err is not KErrNone, then receive is handled.

    if ( err != KErrNone )

        {

        // If request is not active, then it can not be completed, and 

        // something has gone wrong. However, recover (do nothing).

        if ( iParameters.iReceiveDataValid )

            {

            // Receive request active, it is handled.

    _DPRINT( 4, "PhSrv.MesObj.CompleteReceive WRITE1" );   // debug print

            const TInt recBufMaxSize = 

                iParameters.iReceiveBufferMaxSize;

            // Write the whole sent message or the beginnig of it to client data

            // area, i.e ensure that receive message buffer is not overflowed.

            iSubSession.Write(

                iParameters.iReceiveMessage,

                1, 

                aSentMessage.Left( recBufMaxSize ) );

            TInt length = aSentMessage.Length();

            TPckgC < TInt > intPckg( length );

    _DPRINT( 4, "PhSrv.MesObj.CompleteReceive WRITE2" );   // debug print

            // Write the length information to user side.

            iSubSession.Write(

                iParameters.iReceiveMessage,

                2, 

                intPckg );

            // If whole sent message was written to receive buffer, then

            // completion was successful.

            if ( length <= recBufMaxSize )

                {

                err = KErrNone;

                }

            else

                {

                // The receive was not completed fully.

                iParameters.iSkippedSentDataId = aSentDataId;

                }

    _DPRINT( 4, "PhSrv.MesObj.CompleteReceive COMPLETE" );   // debug print

            // Complete the receive request.

            if ( !iParameters.iReceiveMessage.IsNull() )

                {

                iParameters.iReceiveMessage.Complete( KErrNone );

                }

            iParameters.iReceiveDataValid = EFalse;

            }

        }

    _DPRINT( 4, "PhSrv.MesObj.CompleteReceive END" );   // debug print

    return err;

    }

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

// CPhSrvMessengerObject::GetSendDataLength

// 

// Get the Send data.

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

//

TInt CPhSrvMessengerObject::GetSendDataLength()

    {

    return iParameters.iSendPayloadLength;

    }

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

// CPhSrvMessengerObject::GetSendData

// 

// Get the Send data.

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

//

void CPhSrvMessengerObject::GetSendData( TDes8& aDes ) const

    {

    // Read the Send data information from user side.

    // Do not leave, but will panic if pointer not valid descriptor.

    iSubSession.Read(

        iParameters.iSendStatus,

        1,

        aDes );

    }

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

// CPhSrvMessengerObject::GetUid

// 

// Get the Uid.

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

//

const TUid& CPhSrvMessengerObject::GetUid() const

    {

    return iParameters.iCategoryUid;

    }

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

// CPhSrvMessengerObject::SentDataId

// 

// Get the sent data ID.

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

//

TUint CPhSrvMessengerObject::SentDataId()

    {

    return iParameters.iSentDataId;

    }

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

// CPhSrvMessengerObject::IsMessageSkipped

// 

// Return information whether the message is skipped or not.

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

//

TBool CPhSrvMessengerObject::IsMessageSkipped(

    const TUint aSentDataId )

    {

    TBool ret = EFalse; // By default message is not skipped.

    // If Skip is active, then everything is OK.

    if ( iParameters.iSkipNextMessage )

        {

        // If the sent data is the same as that it was earlier, then it is 

        // skipped. If the sent message is not the same, then it is not skipped.

        if ( iParameters.iSkippedSentDataId == aSentDataId )

            {

            // This message is skipped.

            ret = ETrue;

            }

        else

            {

            // This message is not skipped.

            iParameters.iSkipNextMessage = EFalse;

            iParameters.iSkippedSentDataId = KPhSrvNullId; // Set to not valid.

            }

        }

    return ret;

    }

// End of File