/*

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

*

*/

// INCLUDE FILES

#include "cphsrvserver.h" 

#include "cphsrvsession.h" 

#include "cphsrvsubsessionbase.h" 

#include "phsrvsubsessionfactory.h" 

#include "phcltclientserver.h" 

// CONSTANTS

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

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

// CPhSrvSession::NewL

// Two-phased constructor.

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

//

CPhSrvSession* CPhSrvSession::NewL( CPhSrvServer& aServer )   

    {

    CPhSrvSession* self = new ( ELeave ) CPhSrvSession();

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop();

    return self;

    }

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

// CPhSrvSession::CPhSrvSession

// C++ constructor can NOT contain any code, that might leave.

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

//

CPhSrvSession::CPhSrvSession() 

    {

    }

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

// CPhSrvSession::~CPhSrvSession

// Destructor.

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

//

CPhSrvSession::~CPhSrvSession()

    {

    if ( iServer )

        {

        iServer->CancelCreateAll( *this );

        }

    delete iObjectIx;

   if ( iContainer )

        {

        iServer->RemoveContainer( iContainer );

        iContainer = NULL;

        }

    }

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

// CPhSrvSession::ServiceL

// 

// Calls DispatchMessageL under trap harness.

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

//

void CPhSrvSession::ServiceL( const RMessage2& aMessage )  

    {

    TRAPD( err, ProcessRequestL( aMessage ) );

    if ( err != KErrNone )

        {

        aMessage.Complete( err );

        }

    }

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

// CPhSrvSession::ProcessRequestL

// 

// Checks the function specified by the client message

// and depending on the type, performs an appropriate action.

//

// If the function is one of the "special" factory sub-session

// creation op-codes, then this session will process it.

//

// If the function is a generic subsession function, then the

// subsession which can handle this function is identified by

// it's unique handle, and it is asked to process the request.

//

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

//

void CPhSrvSession::ProcessRequestL( const RMessage2& aMessage )

    {

    if ( HandleCommandL( aMessage ) )

        {

        return;

        }

    const TInt function = aMessage.Function();

    const TUint32 sid = aMessage.SecureId().iId;

    // Is this a message that results in a new subsession?

    if  ( PhSrvSubSessionFactory::PhSrvSubSessionFactoryIsCreationFunction( 

          function ) )

        {

        if ( !PhSrvSubSessionFactory::PhSrvSubSessionFactoryIsCreationAllowed(

            function,

            sid ) )

            {

            aMessage.Complete( KErrPermissionDenied );

            }

        else

            {

            // Need to create a new subsession

            CPhSrvSubSessionBase* subSession = 

                PhSrvSubSessionFactory::PhSrvSubSessionFactoryCreateLC( 

                    function, 

                    *this );

            // Add to container (takes ownership)

            iContainer->AddL( subSession );

            // Get a handle for the object

            const TInt handle = iObjectIx->AddL( subSession );

            // Inform client of the handle its been allocated

            TPckg<TInt> handlePckg( handle );

            Write( 

                aMessage,

                3,

                handlePckg );

            if ( !aMessage.IsNull() )

                {

                // Complete the message

                aMessage.Complete( KErrNone );

                }

             }    

         }

    else

        {

        // Find an appropriate object and pass the message to it

        // for processing...

        const TInt handle = aMessage.Int3();

        // Fetch the sub-session by its handle

        CObject* object = iObjectIx->At( handle );

        if ( !object )

            {

            PanicClient(

                aMessage,

                EPhCltServerInitiatedPanicInvalidHandle );

            }

        // We can cast the object to a subsession instance, since that's

        // all we store in the object container

        CPhSrvSubSessionBase* subSession = 

            static_cast< CPhSrvSubSessionBase* >( object );

        if ( subSession )

            {

            // Check that the subsession can handle this request

            if ( !subSession->PhSrvMessageDecoderCanProcessMessage( function ) )

                {

                PanicClient(

                    aMessage,

                    EPhCltServerInitiatedPanicInvalidHandle );

                }

            else

                {

                // Get it to process this request

                subSession->PhSrvMessageProcessorHandleMessageL( aMessage );

                }

            }            

        }

    }

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

// CPhSrvSession::SubSessionCount

// 

// Return the number of subsessions

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

//

TInt CPhSrvSession::SubSessionCount() const

    {

    return iContainer->Count();

    }

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

// CPhSrvSession::SubSessionA

// 

// Return a subsession from an index

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

//

CPhSrvSubSessionBase& CPhSrvSession::SubSessionAt( TInt aIndex ) const

    {

    return *static_cast< CPhSrvSubSessionBase* >( ( *iContainer )[ aIndex ] );

    }

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

// CPhSrvSession::CloseSubsession

// 

// Remove object from object index

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

//

void CPhSrvSession::CloseSubSession( const RMessage2& aMessage )

    {

    TInt handle = aMessage.Int3();

    CObject* obj = iObjectIx->At( handle );  

    __ASSERT_ALWAYS( obj, 

        PanicClient(

            aMessage,

            EPhCltServerInitiatedPanicInvalidHandle ) );

    iObjectIx->Remove( handle );

    if ( !aMessage.IsNull() )

        {

        aMessage.Complete( KErrNone );

        }

    }

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

// CPhSrvSession::PanicClient

// 

// Panic the client's thread

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

//

void CPhSrvSession::PanicClient(

    const RMessage2& aMessage,

    TPhCltServerInitiatedPanic aPanic ) const    

    {

    if ( !aMessage.IsNull() )

        {

        _LIT( KPhServerPanicCategory, "PhSrvServer" );

        aMessage.Panic( KPhServerPanicCategory, aPanic );

        }

    }

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

// CPhSrvSession::ConstructL

// 

// Symbian OS 2nd phase constructor

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

//

void CPhSrvSession::ConstructL( CPhSrvServer& aServer )

    {

    iContainer = aServer.NewContainerL();

    iObjectIx = CObjectIx::NewL();   

    iServer = &aServer;

    }

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

// CPhSrvSession::SubSessionUniqueHandle

// 

// Return the unique handle for the specified subsession

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

//

TInt CPhSrvSession::SubSessionUniqueHandle( 

    const CPhSrvSubSessionBase& aSubSession ) const

    {

    // Ensure that the handle really is unique.

    // return iObjectIx->At( &aSubSession ); is unique only in same session.

    return reinterpret_cast<TInt>( &aSubSession );

    }

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

// CPhSrvSession::PhoneServer

// 

// Returns the Phone Server

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

//

CPhSrvServer& CPhSrvSession::PhoneServer() const

    {

    return *static_cast< CPhSrvServer* >( const_cast< CServer2* >( Server() ) );

    }

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

// CPhSrvSession::Write

// 

// Write to the client address space. Panic client upon error

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

//

void CPhSrvSession::Write( 

    const RMessage2& aMessage,

    TInt aLocation,

    const TDesC8& aDes,

    TInt aOffset )

    {

    TInt ret = aMessage.Write( aLocation, aDes, aOffset );

    if ( ret != KErrNone )

        {

        PanicClient( 

            aMessage,

            EPhCltServerInitiatedPanicBadDescriptor );

        }

    }

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

// CPhSrvSession::Read

// 

// Read from the client address space. Panic client upon error

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

//

void CPhSrvSession::Read(

    const RMessage2& aMessage,

    TInt aLocation,

    TDes8& aDes,

    TInt aOffset )

    {

    TInt ret = aMessage.Read( aLocation, aDes, aOffset );

    if ( ret != KErrNone )

        {

        PanicClient( 

            aMessage,

            EPhCltServerInitiatedPanicBadDescriptor );

        }

    }

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

// CPhSrvSession::Read

// 

// Read from the client address space. Panic client upon error

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

//

void CPhSrvSession::Read(

    const RMessage2& aMessage,

    TInt aLocation,

    TDes& aDes,

    TInt aOffset )

    {

    TInt ret = aMessage.Read( aLocation, aDes, aOffset );

    if ( ret != KErrNone )

        {

        PanicClient( 

            aMessage,

            EPhCltServerInitiatedPanicBadDescriptor );

        }

    }

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

// CPhSrvSession::CompleteCreateAll

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

//

void CPhSrvSession::CompleteCreateAll( TInt aError )

    {

    if ( iCreateAll )

        {

        iCreateAll = EFalse;

        iCreateAllMsg.Complete( aError );

        }

    }

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

// CPhSrvSession::HandleCommandL

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

//

TBool CPhSrvSession::HandleCommandL( const RMessage2& aMessage )

    {

    TBool result = EFalse;

    switch ( aMessage.Function() )

        {

        case EPhoneCreateAll:

            result = ETrue;

            iServer->CancelCreateAll( *this );

            iServer->CreateAllL( *this );

            iCreateAll = ETrue;

            iCreateAllMsg = aMessage;

            break;

        default:

            break;

        }

    return result;

    }

//  End of File