/*

* 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 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 Scheduler server's Server class*

*/

// INCLUDE FILES

#include "CCseSchedulerServer.h"                // Header file for this class

#include "CCseSchedulerServerSession.h"         // Server session

#include "CCseSchedulerServerEngine.h"          // Server intelligence aka engine

#include <ipvideo/CseSchedulerClientServerCommon.h>     // Common defines for client and server

#include "CseSchedulerServer.pan"               // Server panic codes

#include "CseDebug.h"                           // Debug macros

#include <e32svr.h>

#include <e32math.h>

#include <e32uid.h>

#include <e32def.h>

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// Platform security. Custom check is applied to all IPCs.

static const int KRangeCount( 1 );

static const TInt SecurityRanges[KRangeCount] =

    {

    0, // Range is from 0 to KMaxTInt

    };

static const TUint8 SecurityRangesPolicy[KRangeCount] =

    {

    CPolicyServer::ECustomCheck

    };

static const CPolicyServer::TPolicy Policy =

    {

    CPolicyServer::EAlwaysPass,

    KRangeCount,

    SecurityRanges,

    SecurityRangesPolicy,

    NULL,

    };

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

const TInt KDbStartTimeout              = 2000000;

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

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

// CCseSchedulerServer::CCseSchedulerServer()

// C++ constructor 

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

//

CCseSchedulerServer::CCseSchedulerServer()

    : CPolicyServer( EPriorityRealTimeServer, Policy, ESharableSessions ),

    iContainerIx( NULL ),

    iObjectCon( NULL ),

    iSessionCount( 0 ),

    iSchedulerEngine( NULL )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::CCseSchedulerServer");

    __DECLARE_NAME( _S( "CCseSchedulerServer" ) );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::CCseSchedulerServer");

    }

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

// CCseSchedulerServer::NewLC()

// 

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

//

CCseSchedulerServer* CCseSchedulerServer::NewLC( )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::NewLC");

    CCseSchedulerServer* self = new ( ELeave ) CCseSchedulerServer;

    CleanupStack::PushL( self );

    self->ConstructL( );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::NewLC");

    return self;

    }

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

// CCseSchedulerServer::ConstructL()

// second-phase constructor; create the object container index.

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

//

void CCseSchedulerServer::ConstructL( )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::ConstructL");

    iContainerIx = CObjectConIx::NewL();

    iObjectCon = iContainerIx->CreateL(); 

    StartL( KCseSchedulerServerName );

    GetEngineObjectL();

    iStarterBreaker = CPeriodic::NewL( CActive::EPriorityStandard );

    // break call chain

	if( !iStarterBreaker->IsActive() )

        {

        // Give client 2 secs to make server session before we check 

        // if server is needed or not.

        iStarterBreaker->Start( KDbStartTimeout,

                                KDbStartTimeout,

                                TCallBack( StarterCallback, this ));

        }

    else

        {

        CSELOGSTRING_HIGH_LEVEL(

            "CCseSchedulerServer::ConstructL - Breaker already active");

        }

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::ConstructL");    

    }

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

// CCseSchedulerServer::~CCseSchedulerServer()

// Destructor.

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

//

CCseSchedulerServer::~CCseSchedulerServer()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::~CCseSchedulerServer");

    DeleteSchedulerEngine();

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::~CCseSchedulerServer");

    }

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

// CCseSchedulerServer::ThreadFunction()

// The active scheduler is installed and started here.

// (other items were commented in a header).

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

//

TInt CCseSchedulerServer::ThreadFunction( )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::ThreadFunction");

	CTrapCleanup* cleanupStack = CTrapCleanup::New();    

    if ( !cleanupStack )

        {

        CSELOGSTRING_HIGH_LEVEL("CCseSchedulerServer::ThreadFunction - Could not create cleanupstack: %d");

        return KErrNone;

        }

    TRAPD( err, ThreadFunctionL( ) );

    if ( err )

        {

        CSELOGSTRING2_HIGH_LEVEL("CCseSchedulerServer::ThreadFunction - Main thread leaved: %d", err );

        }

    delete cleanupStack;    

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::ThreadFunction");

    return KErrNone;

    }

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

// CCseSchedulerServer::ThreadFunctionL()

//

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

//

void CCseSchedulerServer::ThreadFunctionL( )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::ThreadFunctionL");

    // Construct active scheduler

    CActiveScheduler* activeScheduler = new ( ELeave ) CActiveScheduler;

    CleanupStack::PushL( activeScheduler ); // |-> 1

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

    // Construct our server, pushed cleanup stack and leaved there

    CCseSchedulerServer* server = CCseSchedulerServer::NewLC( );  // |-> 2    

    // Signal server is up

    RProcess::Rendezvous( KErrNone );

    // Start handling requests

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( server ); // 2<-|

    CleanupStack::PopAndDestroy( activeScheduler ); // 1<-|

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::ThreadFunctionL");

    }

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

// CCseSchedulerServer::PanicServer

// Utility - panic the server

// (other items were commented in a header).

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

void CCseSchedulerServer::PanicServer( TCseSchedulerServPanic aPanic )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::PanicServer");

    _LIT( KSchedulerServer, "SchedulerServer" );

    User::Panic( KSchedulerServer, aPanic );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::PanicServer");

    }

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

// CCseSchedulerServer::GetEngineObjectL()

//

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

//

CCseSchedulerServerEngine* CCseSchedulerServer::GetEngineObjectL()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::GetEngineObjectL");

    if ( iObjectCon->Count() == 0 )

        {

        // Create scheduler engine

        iSchedulerEngine = CCseSchedulerServerEngine::NewL( *this );

        // Add our engine to container

        iObjectCon->AddL( iSchedulerEngine );

        }

    else

        {

        // default implementation return KErrNone.

        if ( KErrNone != iSchedulerEngine->Open() )

            {

            User::Leave( KErrGeneral );

            }

        }

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::GetEngineObjectL");

    // We have only one object in our container

    return iSchedulerEngine;

    }

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

// CCseSchedulerServer::Inc()

// 

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

//

void CCseSchedulerServer::Inc()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::Inc");

    if ( iSessionCount!=KErrNotFound )

        {

        iSessionCount++;

        }

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::Inc");

    }

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

// CCseRTPServer::Dec()

// 

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

//

void CCseSchedulerServer::Dec()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::Dec");

    iSessionCount--;

    if ( iSessionCount<=0 )

        {

        StopServer();

        }

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::Dec");

    }

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

// CCseSchedulerServer::DeleteSchedulerEngine

// Stops active scheduler and deletes object container and other objects.

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

void CCseSchedulerServer::DeleteSchedulerEngine()

    {

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::DeleteSchedulerEngine");

    if ( iContainerIx )

        {

        if( iObjectCon->Count() > 0 )

            {

            iSchedulerEngine->Close();

            }

        iContainerIx->Remove( iObjectCon );

        delete iContainerIx; 

		iContainerIx = NULL;

		iSchedulerEngine = NULL;

        }

    if( iStarterBreaker && iStarterBreaker->IsActive() )

        {

        iStarterBreaker->Cancel();

        }

    delete iStarterBreaker;    

    iStarterBreaker = NULL;

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::DeleteSchedulerEngine");

    }

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

// CCseSchedulerServer::NewSessionL()

// 

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

//

CSession2* CCseSchedulerServer::NewSessionL( const TVersion& aVersion,

                                             const RMessage2& /*aMessage*/ ) const

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::NewSessionL");

    // Check version is ok

    TVersion v( KCseServMajorVersionNumber,

                KCseServMinorVersionNumber,

                KCseServBuildVersionNumber );

    if ( !User::QueryVersionSupported( v, aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::NewSessionL");        

    // Make new session

	return CCseSchedulerServerSession::NewL( ( CCseSchedulerServer* ) this );

    }

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

// CCseSchedulerServer::StopServer

// Stops the server thread if no sessions active.

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

//

void CCseSchedulerServer::StopServer()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::StopServer");

    TBool schedulerActive( iSchedulerEngine->IsSchedulerActive() );    

    CSELOGSTRING2_HIGH_LEVEL("CCseSchedulerServer::StopServer - Session count: %d", iSessionCount);    

    if ( (iSessionCount<=0) && (schedulerActive == EFalse))

        {

        CSELOGSTRING_HIGH_LEVEL("CCseSchedulerServer::StopServer - Call ActiveScheduler::Stop()");

        CActiveScheduler::Stop();

        }        

    CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::StopServer");

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

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

// StartThread()

// Start the server thread. This is called from the client.

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

//

TInt CCseSchedulerServer::StartThread()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::StartThread");

#if _DEBUG

    __UHEAP_MARK;

#endif

    // Check server not already started

    TFindServer findCountServer( KCseSchedulerServerName );

    TFullName name;

    if ( findCountServer.Next( name ) == KErrNone )

        { 

        // Found server already

        RProcess::Rendezvous( KErrNone );

        CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::StartThread - Return value: KErrAlreadyExists");

        return KErrAlreadyExists;

        }

    ThreadFunction( );

#if _DEBUG

    __UHEAP_MARKEND;

#endif    

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::StartThread - Server down!");

    // All well

    return KErrNone;

    }

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

// CCseSchedulerServer::CustomSecurityCheckL()

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

//

CPolicyServer::TCustomResult CCseSchedulerServer::CustomSecurityCheckL(

    const RMessage2& aMsg,

    TInt& /*aAction*/,

    TSecurityInfo& /*aMissing*/ )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::CustomSecurityCheckL");

    TCustomResult retVal ( EFail );

    // Check the messagge function range

    if ( aMsg.Function() > ECseRequestBase && 

         aMsg.Function() < ECseRequestLast )

        {

        // Check if the client has required capabilities

        // From .mmp-file capablity NetworkControl

        if( // From .mmp-file following are CAP_SERVER capabilities

            ! aMsg.HasCapability(ECapabilityNetworkServices ) ||

            ! aMsg.HasCapability(ECapabilityLocalServices ) ||

            ! aMsg.HasCapability(ECapabilityLocation ) ||

            ! aMsg.HasCapability(ECapabilityReadUserData ) ||

            ! aMsg.HasCapability(ECapabilityWriteUserData ) ||

            ! aMsg.HasCapability(ECapabilityReadDeviceData ) ||

            ! aMsg.HasCapability(ECapabilityWriteDeviceData ) ||        

            ! aMsg.HasCapability(ECapabilityUserEnvironment ) ||

            ! aMsg.HasCapability(ECapabilitySwEvent ) )

            {         

            CSELOGSTRING2_HIGH_LEVEL(

                "CCseSchedulerServer::CustomSecurityCheckL() No capability for message %d!!!",

                aMsg.Function() );                 

            }

        else

            {

            CSELOGSTRING2_HIGH_LEVEL(

                "CCseSchedulerServer::CustomSecurityCheckL() Message %d inside range and capabilities ok",

                aMsg.Function() );

            retVal = EPass;

            }

        }

    else

        {

        CSELOGSTRING2_HIGH_LEVEL(

            "CCseSchedulerServer::CustomSecurityCheckL() Message %d outside known range!!!",

            aMsg.Function() );            

        }

    if( retVal == EPass )

        {

        CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::CustomSecurityCheckL - Passed");

        }

    else

        {

        CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::CustomSecurityCheckL - Failed");

        }    

    return retVal;

    }

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

// CCseSchedulerServerEngine::StarterCallback

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

//

TInt CCseSchedulerServer::StarterCallback( TAny* aPtr )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::StarterCallback");

	TBool retVal( EFalse);

	retVal = static_cast<CCseSchedulerServer*>( aPtr )->HandleStarterCallback();

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::StarterCallback");

	return retVal;

	}

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

// CCseSchedulerServerEngine::HandleCompletitionCallback

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

//

TInt CCseSchedulerServer::HandleStarterCallback() 

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseSchedulerServer::HandleStarterCallback ");

	// We dont want to use periodic anymore, so we cancel it. We just wanted to

	// make call here 2 secs after server has been created.

	iStarterBreaker->Cancel();  

	// Check if server can be stopped.

    iSchedulerEngine->RequestReschedule();

	CSELOGSTRING_HIGH_LEVEL("<<<CCseSchedulerServer::HandleStarterCallback ");

	return EFalse;

	}

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

// E32Main()

// Server startup

// Returns: KErrNone

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

//

GLDEF_C TInt E32Main()

    {

    return CCseSchedulerServer::StartThread();

    }

// End of File