/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:    Implementation of RBF server's CCRSession class*
*/




// INCLUDE FILES
#include "CCRSession.h"
#include "CCRServer.h"
#include "CCREngine.h"
#include <ipvideo/CRTypeDefs.h>
#include "videoserviceutilsLogger.h"

// CONSTANTS
// None

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

// -----------------------------------------------------------------------------
// CCRSession::CCRSession()
// C++ constructor
// -----------------------------------------------------------------------------
//
CCRSession::CCRSession() : CSession2(), iResourceCount( 0 )
    {
    __DECLARE_NAME( _S( "CCRSession" ) );
    }

// -----------------------------------------------------------------------------
// CCRSession::NewL()
// Two-phased constructor. 
// -----------------------------------------------------------------------------
//
CCRSession* CCRSession::NewL( CCRServer* aServer )
    {
    CCRSession* self = new( ELeave ) CCRSession();
    CleanupStack::PushL( self );
    self->ConstructL( aServer );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CCRSession::ConstructL()
// second-phase C++ constructor
// -----------------------------------------------------------------------------
//
void CCRSession::ConstructL( CCRServer* aServer )
    {
    LOG( "CCRSession::ConstructL" );

    aServer->Inc();
    // Create new object index
    iObjects = CObjectIx::NewL();
    }
    
// -----------------------------------------------------------------------------
// CCRSession::~CCRSession()
// Destructor.
// -----------------------------------------------------------------------------
//
CCRSession::~CCRSession()
    {
    LOG( "CCRSession::~CCRSession" );
    
    // Deletes objects
    delete iObjects;
    }

// -----------------------------------------------------------------------------
// CCRSession::ServiceL()
// -----------------------------------------------------------------------------
//
void CCRSession::ServiceL( const RMessage2& aMessage )
    {
    switch ( aMessage.Function() )
        {
        case ECRServCreateSubSession:
        case ECRServCloseSubSession:
        case ECRServCloseSession:    
            {
            LOG1( "CCRSession::ServiceL(), aMessage: %d", aMessage.Function() );
            TRAPD( err, DispatchMessageL( aMessage ) );
            aMessage.Complete( err );
            }
            break;

        default:
            {
            // Ok, but must be subsession relative
            CCREngine* engine = ( CCREngine* )iObjects->At( aMessage.Int3() );
            if ( engine == NULL )
                {    
                LOG( "CCRSession::ServiceL(), Null engine !" );
                aMessage.Complete( KErrBadHandle );
                PanicClient( KErrBadHandle );
                }
            else
                {
                // this is the normal route, 
                // all engine commands go this way
                engine->GeneralServiceL( aMessage );
                }
            }
            break;
        }
    }

// -----------------------------------------------------------------------------
// CCRSession::DispatchMessageL()
// -----------------------------------------------------------------------------
//
void CCRSession::DispatchMessageL( const RMessage2& aMessage )
    {
    // Check for session-relative requests
    switch ( aMessage.Function() )
        {
        case ECRServCreateSubSession:
            NewObjectL( aMessage );
            break;

        case ECRServCloseSubSession:
            DeleteObject( aMessage.Int3() );
            break;
        
        case ECRServCloseSession:
            Server()->Dec();
            break;
        
        default:
            // None
            break;
        }
    }

// -----------------------------------------------------------------------------
// CCRSession::NewObjectL()
//
// -----------------------------------------------------------------------------
//
void CCRSession::NewObjectL( const RMessage2& aMessage )
    {
    LOG( "CCRSession::NewObjectL() in" );

    CObject* obj = Server()->GetEngineObjectL();
    TInt handle( iObjects->AddL( obj ) );
    LOG1( "CCRSession::NewObjectL(), handle: %d", handle );
    
    // Write the handle to client
    TPckg<TInt> handlePckg( handle );
    TRAPD( err, aMessage.WriteL( 3, handlePckg ) );
    if ( err )
        {
        PanicClient( KErrBadDescriptor );
        return;
        }
        
    // Notch up another resource
    iResourceCount++;
    LOG1( "CCRSession::NewObjectL() out, iResourceCount: %d", iResourceCount );
    }

// -----------------------------------------------------------------------------
// CCRSession::DeleteObject()
// -----------------------------------------------------------------------------
//
void CCRSession::DeleteObject( TUint aHandle )
    {
    LOG1( "CCRSession::DeleteObject() in, aHandle: %u", aHandle );

    // Panic if bad handle
    CCREngine* engine = ( CCREngine* )iObjects->At( aHandle );
    if ( engine == NULL )
        {
        PanicClient( KErrNotFound ); 
        }
        
    // Deletes engine
    iResourceCount--;
    iObjects->Remove( aHandle );

    LOG1( "CCRSession::DeleteObject() out, iResourceCount: %d", iResourceCount );
    }

// -----------------------------------------------------------------------------
// CCRSession::CountResources()
//
// -----------------------------------------------------------------------------
//
TInt CCRSession::CountResources()
    {
    return iResourceCount;
    }

// -----------------------------------------------------------------------------
// CCRSession::PanicClient()
// -----------------------------------------------------------------------------
//
void CCRSession::PanicClient( TInt aPanic ) const
    {
    _LIT( KTxtSessionPanic, "RbfSession" );
    User::Panic( KTxtSessionPanic, aPanic );
    }

//  End of File