/*
* 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 CR servers server class*
*/




// INCLUDE FILES
#include "CCRServer.h"
#include "CCRSession.h"
#include "CCREngine.h"
#include <ipvideo/CRTypeDefs.h> // Constants exported from client library
#include <e32svr.h>
#include <e32math.h>
#include <e32uid.h>
#include "videoserviceutilsLogger.h"

// 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,
    };

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

// -----------------------------------------------------------------------------
// CCRServer::NewLC()
// 
// -----------------------------------------------------------------------------
//
CCRServer* CCRServer::NewLC(  )
    {
    CCRServer* self = new( ELeave ) CCRServer;
    CleanupStack::PushL( self );  
    self->ConstructL( );
    return self;
    }

// -----------------------------------------------------------------------------
// CCRServer::CCRServer()
// C++ constructor 
// -----------------------------------------------------------------------------
//
CCRServer::CCRServer()
  : CPolicyServer( EPriorityRealTimeServer, Policy, ESharableSessions ),
    iSessionCount( 0 )
    {
    __DECLARE_NAME( _S( "CCRServer" ) );
    }

// -----------------------------------------------------------------------------
// CCRServer::ConstructL()
// second-phase constructor; create the object container index.
// -----------------------------------------------------------------------------
//
void CCRServer::ConstructL(  )
    {
    LOG( "CCRServer::ConstructL()" );    
    
    iContainerIx = CObjectConIx::NewL();
    iObjectCon = iContainerIx->CreateL();
    
    StartL( KCRServerNameExe );
    }

// -----------------------------------------------------------------------------
// CCRServer::~CCRServer()
// Destructor.
// -----------------------------------------------------------------------------
//
CCRServer::~CCRServer()
    {
    LOG( "CCRServer::~CCRServer()" );

    DeleteRtpEngine();
    }

// -----------------------------------------------------------------------------
// CCRServer::ThreadFunction()
// The active scheduler is installed and started here.
// -----------------------------------------------------------------------------
//
TInt CCRServer::ThreadFunction(  )
    {
    CTrapCleanup* cleanupStack = CTrapCleanup::New();    
    if ( !cleanupStack )
        {
        PanicServer( KErrNoMemory );
        }

    TRAPD( err, ThreadFunctionL( ) );
    if ( err )
        {
        PanicServer( KErrServerTerminated );
        }

    delete cleanupStack;
    cleanupStack = NULL;
    
    return KErrNone;    
    }

// -----------------------------------------------------------------------------
// CCRServer::ThreadFunctionL()
//
// -----------------------------------------------------------------------------
//
void CCRServer::ThreadFunctionL(  )
    {
    LOG( "CCRServer::ThreadFunctionL() - In" );

    // 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
    CCRServer* server = CCRServer::NewLC( );  // |-> 2    
    
    // Signal server is up
    RProcess::Rendezvous( KErrNone );

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

    CleanupStack::PopAndDestroy( server ); // 2<-|
    CleanupStack::PopAndDestroy( activeScheduler ); // 1<-|
    
    LOG( "CCRServer::ThreadFunctionL() - Out" );    
    }

// -----------------------------------------------------------------------------
// CCRServer::SignalClientL
// Signal the client that server is running.
// -----------------------------------------------------------------------------
void CCRServer::SignalClientL()
    {
    RSemaphore semaphore;
    User::LeaveIfError( semaphore.OpenGlobal( KCRServerSemaphoreName ) );
    semaphore.Signal();
    semaphore.Close();
    }

// -----------------------------------------------------------------------------
// CCRServer::PanicServer
// Utility - panic the server
// -----------------------------------------------------------------------------
void CCRServer::PanicServer( TInt aPanic )
    {
    LOG1( "CCRServer::PanicServer(), aPanic: %d", aPanic );
    
    User::Panic( KCRServerNameExe, aPanic );
    }

// -----------------------------------------------------------------------------
// CCRServer::GetEngineObjectL()
//
// -----------------------------------------------------------------------------
//
CCREngine* CCRServer::GetEngineObjectL()
    {
    if ( iObjectCon->Count() == 0 )
        {
        // Create CR engine
        iEngine = CCREngine::NewL( );

        // Add our engine to container
        iObjectCon->AddL( iEngine );
        }
    else
        {
        // default implementation return KErrNone.
        if ( KErrNone != iEngine->Open() )
            {
            User::Leave( KErrGeneral );
            }
        }

    // We have only one object in our container
    return iEngine;
    }

// -----------------------------------------------------------------------------
// CCRServer::Inc()
// 
// -----------------------------------------------------------------------------
//
void CCRServer::Inc()
    {
    iSessionCount++;
    LOG1( "CCRServer::Inc(), New iSessionCount: %d", iSessionCount );
    }

// -----------------------------------------------------------------------------
// CCRServer::Dec()
// 
// -----------------------------------------------------------------------------
//
void CCRServer::Dec()
    {
    iSessionCount--;
    LOG1( "CCRServer::Dec(), New iSessionCount: %d", iSessionCount );

    if ( iSessionCount <= 0 )
        {
        StopServer();
        }
    }

// -----------------------------------------------------------------------------
// CCRServer::NewSessionL()
// 
// -----------------------------------------------------------------------------
//
CSession2* CCRServer::NewSessionL(
    const TVersion& aVersion,
    const RMessage2& /*aMessage*/ ) const
    {
    // Check version is ok
    TVersion v( KCRServMajorVersionNumber,
                KCRServMinorVersionNumber,
                KCRServBuildVersionNumber );
    
    if ( !User::QueryVersionSupported( v, aVersion ) )
        {
        User::Leave( KErrNotSupported );
        }
        
    // Make new session
    return CCRSession::NewL( ( CCRServer* ) this );
    }

// -----------------------------------------------------------------------------
// CCRServer::StopServer
// Stops the server thread if no sessions active.
// -----------------------------------------------------------------------------
//
void CCRServer::StopServer()
    {
    LOG( "CCRServer::StopServer()" );    
    
    CActiveScheduler::Stop();
    }
    
// -----------------------------------------------------------------------------
// CCRServer::DeleteRtpEngine
// Stops active scheduler and deletes object container and other objects.
// -----------------------------------------------------------------------------
//
void CCRServer::DeleteRtpEngine()
    {
    LOG1( "CCRServer::DeleteRtpEngine(), iContainerIx: %d", iContainerIx );
    
    if ( iContainerIx )
        {
        iContainerIx->Remove( iObjectCon );
        delete iContainerIx; iContainerIx = NULL;
        }
    }

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

// -----------------------------------------------------------------------------
// StartThread()
// Start the server thread. This is called from the client.
// -----------------------------------------------------------------------------
//
TInt CCRServer::StartThread()
    {
#ifdef _DEBUG
    __UHEAP_MARK;
#endif
    
    LOG( "CCRServer::StartThread() - In" );
    // Check server not already started
    TFindServer findCountServer( KCRServerNameExe );
    TFullName name;
    if ( findCountServer.Next( name ) == KErrNone )
        { 
        // Found server already
        TRAP_IGNORE( CCRServer::SignalClientL() );
        return KErrAlreadyExists;
        }
    
    ThreadFunction( );
    
    LOG( "CCRServer::StartThread() - Out" );

#ifdef _DEBUG
    __UHEAP_MARKEND;
#endif
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// E32Main()
// Server startup
// Returns: KErrNone
// -----------------------------------------------------------------------------
//
GLDEF_C TInt E32Main()
    {
    return CCRServer::StartThread();
    }
    
// --------------------------------------------------------------------------
// CCRServer::CustomSecurityCheckL()
// --------------------------------------------------------------------------
//
CPolicyServer::TCustomResult CCRServer::CustomSecurityCheckL(
    const RMessage2& aMsg,
    TInt& /*aAction*/,
    TSecurityInfo& /*aMissing*/ )
    {
    
    TCustomResult retVal ( EFail );
    
    // Check the messagge function range
    if ( ( aMsg.Function() > ECRServBase && 
           aMsg.Function() < ECRServLastEnum ) ||
         ( aMsg.Function() > ECRLiveTvBase && 
           aMsg.Function() < ECRLiveTvLastEnum ) )
        {
        // Check if the client has required capabilities                
        // From .mmp-file following are CAP_APPLICATION capabilities
        if( ! aMsg.HasCapability(ECapabilityNetworkServices ) ||
            ! aMsg.HasCapability(ECapabilityLocalServices ) ||
            ! aMsg.HasCapability(ECapabilityLocation ) ||
            ! aMsg.HasCapability(ECapabilityReadUserData ) ||
            ! aMsg.HasCapability(ECapabilityWriteUserData ) ||
            ! aMsg.HasCapability(ECapabilityReadDeviceData ) ||
            ! aMsg.HasCapability(ECapabilityWriteDeviceData ) ||
            ! aMsg.HasCapability(ECapabilitySwEvent ) )
            {
            LOG1(
                "CCRServer::CustomSecurityCheckL() No capability for message %d!!!",
                aMsg.Function() );                 
            }
        else
            {
            LOG1(
                "CCRServer::CustomSecurityCheckL() Message %d inside range and capabilities ok",
                aMsg.Function() );
            retVal = EPass;
            }        
        }
    else
        {
        LOG1(
            "CCRServer::CustomSecurityCheckL() Message %d outside known range!!!",
            aMsg.Function() );            
        }
       
    return retVal;

    }
// End of File