/** @file
* Copyright (c) 2005-2006 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:  CUpnpAVCPEngine
*
*/


// INCLUDE FILES
#include <e32svr.h>
#include "upnpavcpengine.h"
#include "upnpavcpenginesession.h"
#include "upnpavcpmanager.h"
#include "upnpavcpenginecommon.h"
#include "upnpmdebug.h"

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::CUpnpAVCPEngine
// constructor.
// -----------------------------------------------------------------------------
//
CUpnpAVCPEngine::CUpnpAVCPEngine( TInt aPriority )
    : CServer2( aPriority )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::~CUpnpAVCPEngine
// destructor.
// -----------------------------------------------------------------------------
//
CUpnpAVCPEngine::~CUpnpAVCPEngine()
    {   
    delete iAVCPManger;
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CUpnpAVCPEngine* CUpnpAVCPEngine::NewLC()
    {
    CUpnpAVCPEngine* engine = new (ELeave) CUpnpAVCPEngine( EPriorityNormal );
    CleanupStack::PushL( engine );
    engine->ConstructL() ;
    return engine;
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::ConstructL()
    {
     DEBUGSTRING(("CUpnpAVCPEngine::ConstructL "));
    iAVCPManger = CUpnpAVCPManager::NewL();
    StartL( KAVCPEngineName );
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::NewSessionL
// Create new session.
// -----------------------------------------------------------------------------
//
CSession2* CUpnpAVCPEngine::NewSessionL( const TVersion& aVersion, const RMessage2& aMessage ) const
    {
    // Check it's the right version
    if ( !User::QueryVersionSupported( TVersion( 
            KAVCPEngineMajorVersionNumber,
            KAVCPEngineMinorVersionNumber,
            KAVCPEngineBuildVersionNumber ),
            aVersion ) )
        {
        User::Leave( KErrNotSupported );
        }

	RThread client;
	aMessage.Client(client); 
    return CUpnpAVCPEngineSession::NewL( client, *const_cast<CUpnpAVCPEngine*> ( this ), *const_cast<CUpnpAVCPManager*> (iAVCPManger) );
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::IncrementSessions
// Increment sessions.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::IncrementSessions(CUpnpAVCPEngineSession* /*aObserver*/)
    {    
    iSessionCount++;   
    DEBUGSTRING(("IncrementSessions (%d)", iSessionCount));
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::DecrementSessions
// Decrement sessions.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::DecrementSessions( CUpnpAVCPEngineSession* aObserver)
    {
    TRAP_IGNORE( iAVCPManger->CleanupSessionL(aObserver) );
    iSessionCount--; 
    DEBUGSTRING(("DecrementSessions (%d)", iSessionCount));    
    if ( iSessionCount <= 0 )
		{
		CActiveScheduler::Stop();
		}
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::RunError
// RunError is called when RunL leaves.
// -----------------------------------------------------------------------------
//
TInt CUpnpAVCPEngine::RunError( TInt aError )
    {
    DEBUGSTRING(("CUpnpAVCPEngine::RunError (%d)", aError));    
    
    if ( aError == KErrBadDescriptor )
        {
        // A bad descriptor error implies a badly programmed client, so panic it;
        // otherwise report the error to the client
        PanicClient( Message(), /*EMessageHandlerBadDescriptor*/EAVCPEngineGenerealPanic );
        }
    else
        {
        Message().Complete( aError );
        }

    // The leave will result in an early return from CServer::RunL(), skipping
    // the call to request another message. So do that now in order to keep the
    // server running.
    ReStart();

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::PanicClient
// Panic client.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::PanicClient( const RMessage2& aMessage, 
                                   TAVCPEnginePanic aPanic )
    {
    aMessage.Panic( KAVCPEngine, aPanic );
    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::PanicServer
// Panic server.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::PanicServer( TAVCPEnginePanic aPanic )
    {
    User::Panic( KAVCPEngine, aPanic );
    }


// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::ThreadFunctionL
// Create and start the server.
// -----------------------------------------------------------------------------
//
void CUpnpAVCPEngine::ThreadFunctionL()
    {
    // Construct active scheduler
    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
    CleanupStack::PushL( activeScheduler );

    // Install active scheduler
    // We don't need to check whether an active scheduler is already installed
    // as this is a new thread, so there won't be one
    CActiveScheduler::Install( activeScheduler );

	User::RenameThread( KAVCPEngineName );
    // Construct our server
    CUpnpAVCPEngine* engine = CUpnpAVCPEngine::NewLC();    // Anonymous

    RProcess::Rendezvous(KErrNone);

	// Start handling requests
	CActiveScheduler::Start();	

    CleanupStack::PopAndDestroy( engine );
	CleanupStack::PopAndDestroy( activeScheduler );

    }

// -----------------------------------------------------------------------------
// CUpnpAVCPEngine::ThreadFunctionL
// Create and start the server.
// -----------------------------------------------------------------------------
//
TInt CUpnpAVCPEngine::ThreadFunction( TAny* /*aNone*/ )
    {
    __UHEAP_MARK;
    
    CTrapCleanup* cleanupStack = CTrapCleanup::New();
    if ( !(cleanupStack) )
        {
        PanicServer( EAVCPEngineGenerealPanic );
        }

    TRAPD( err, ThreadFunctionL() );
    if ( err != KErrNone )
        {
        PanicServer( EAVCPEngineGenerealPanic );
        }

    delete cleanupStack;
    cleanupStack = NULL;

    __UHEAP_MARKEND;

    return KErrNone;
    }


// ============================= LOCAL FUNCTIONS ===============================

TInt E32Main()
    {
	return CUpnpAVCPEngine::ThreadFunction(NULL);
    }

// End of File