/*

* Copyright (c) 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:  ?Description

*

*/

#include "musmanagerserver.h"

#include "musunittesting.h"

#include "muslogger.h"

#include "musmanageripccommon.h"

#include "musmanagerserverclosetimer.h"

#include "musmanagerservercore.h"

#include "musmanagerserverplatsecpolicy.h"

#include "musmanagerserversession.h"

// CONSTANTS

const TUint KServerCloseWaitTime = 500; // milliseconds

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

// CMusManagerServer::NewL

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

//

CMusManagerServer* CMusManagerServer::NewL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer* CMusManagerServer::NewL()" );

    CMusManagerServer* self = CMusManagerServer::NewLC();

    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer* CMusManagerServer::NewL()" );

    return self;

    }

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

// CMusManagerServer::NewLC

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

//

CMusManagerServer* CMusManagerServer::NewLC()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer* CMusManagerServer::NewLC()" );

    CMusManagerServer* self = new( ELeave ) CMusManagerServer( EPriorityHigh );

    CleanupStack::PushL( self );

    self->ConstructL();

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer* CMusManagerServer::NewLC()" );

    return self;

    }

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

// CMusManagerServer::CMusManagerServer

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

//

CMusManagerServer::CMusManagerServer ( TInt aPriority )

    : CPolicyServer( aPriority, KMusManagerServerPlatSecPolicy )

    {

    }

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

// CMusManagerServer::ConstructL

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

//

void CMusManagerServer::ConstructL()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::ConstructL()" );

    iActiveScheduler = new( ELeave ) CActiveScheduler ();

    CActiveScheduler::Install( iActiveScheduler );

    StartL( KMusManagerServerName );

    iCloseTimer = CMusManagerServerCloseTimer::NewL();

    iServerCore = CMusManagerServerCore::NewL( *this );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::ConstructL()" );

    }

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

// CMusManagerServer::~CMusManagerServer

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

//

CMusManagerServer::~CMusManagerServer()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::~CMusManagerServer()" );

    delete iCloseTimer;

	//iServerCore.StopMonitoring();

    delete iServerCore;

    delete iActiveScheduler;

    CActiveScheduler::Install( NULL );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::~CMusManagerServer()" );

    }

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

// CMusManagerServer::IncrementSessions

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

//

void CMusManagerServer::StopServer()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::StopServer()" );

    iCloseTimer->StopActiveSchedulerAfter( KServerCloseWaitTime );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::StopServer()" );

    }

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

// CMusManagerServer::IncrementSessions

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

//

void CMusManagerServer::IncrementSessions()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::IncrementSessions()" );

    iSessionCount++;

    if ( iCloseTimer->IsActive() )

        {

        iCloseTimer->Cancel();

        }

    MUS_LOG1( "mus: [MUSSRV]  <- CMusManagerServer::IncrementSessions( %d )",

              iSessionCount );

    }

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

// CMusManagerServer::DecrementSessions

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

//

void CMusManagerServer::DecrementSessions()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::DecrementSessions()" );

    iSessionCount--;

    if( iSessionCount == 0 )

        {

        iServerCore->EventNoSessions();

        }

    MUS_LOG1( "mus: [MUSSRV]  <- CMusManagerServer::DecrementSessions( %d )",

              iSessionCount );

    }

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

// CMusManagerServer::RunError

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

//

TInt CMusManagerServer::RunError(TInt aError)

    {

    MUS_LOG1( "mus: [MUSSRV]     -> CMusManagerServer::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

        Message().Panic( KMusManagerServer(), EBadDescriptor );

        }

    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();

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::RunError()" );

    return KErrNone; // handled the error fully

    }

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

// CMusManagerServer::NewSessionL

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

//

CSession2* CMusManagerServer::NewSessionL(

    const TVersion &aVersion,

    const RMessage2& /*aMessage*/ ) const

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::NewSessionL()" );

    // check we're the right version

    if ( !User::QueryVersionSupported( TVersion( KMusManagerServerMajorVersionNumber,

                                                 KMusManagerServerMinorVersionNumber,

                                                 KMusManagerServerBuildVersionNumber),

                                                 aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    // make new session

    CMusManagerServerSession* session = CMusManagerServerSession::NewL(

                const_cast<CMusManagerServer&>( *this ),

                *iServerCore );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::NewSessionL()" );

    return session;

    }

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

// CMusManagerServer::SessionCount

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

//

TUint CMusManagerServer::SessionCount()

    {

    MUS_LOG( "mus: [MUSSRV]  -> CMusManagerServer::SessionCount()" );

    MUS_LOG( "mus: [MUSSRV]  <- CMusManagerServer::SessionCount()" );

    return iSessionCount;

    }