/*
* Copyright (c) 2004 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:  DRMClockServer manages the all operation to the DRMClock
*
*/



// INCLUDE FILES
#include <e32std.h>
#include "DRMClockServer.h"
#include "drmlog.h"
#include "drmclockclientserver.h"
#include "drmcommonclientserver.h"

// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES  
// CONSTANTS
// MACROS


// LOCAL CONSTANTS AND MACROS
const TUint8 KMaxStartTries = 3;
const TInt KWaitingTime = 100000; // 1 secs
_LIT( KClockThread, "DRMClockServer" );

// MODULE DATA STRUCTURES
using DRMClock::KServerMajorVersion;
using DRMClock::KServerMinorVersion;
using DRMClock::KServerBuildVersion;

// LOCAL FUNCTION PROTOTYPES
LOCAL_C TInt StartClockServer( RSemaphore& aClientSem );

// FORWARD DECLARATIONS

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


// -----------------------------------------------------------------------------
// Function StartClockServer().
// This function starts the actual server under TRAP harness and starts
// waiting for connections. This function returns only if there has been
// errors during server startup or the server is stopped for some reason.
// 
// Returns: TInt: Symbian OS error code.
// -----------------------------------------------------------------------------
LOCAL_C TInt StartClockServer( RSemaphore& aClientSem ) 

    {
    TInt error = KErrNone;
    CDRMClockServer* server = NULL;

    TUint8 count = 0;

    do 
    {
       DRMLOG2( _L( "unipertar.exe: StartClockServer: %d" ), error );
       
       ++count;
       
       TRAP( error, ( server = CDRMClockServer::NewL() ) );
       
       if ( error ) 
       {
          User::After( TTimeIntervalMicroSeconds32(KWaitingTime) );
       }
       
    } while( error && ( count <= KMaxStartTries ) );
    
    if( error ) 
    {
        // Failed
        return error;
        }
       
    // Release the semaphore...
    aClientSem.Signal();
    
    // and close it. Otherwise there will be an unused handle to the semaphore
    // until the phone is switched off.
    aClientSem.Close();
    
    DRMLOG( _L( "unipertar.exe: StartClockServer: starting..." ) );

    // Start waiting for connections
    CActiveScheduler::Start();
    
    // Dying.
    
    DRMLOG( _L( "unipertar.exe: StartClockServer: dying" ) );

    delete server;
    
    return KErrNone;
    }

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

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

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
CDRMClockServer::~CDRMClockServer() 
    {
    if( iDRMClock )
        {
        delete iDRMClock;
        iDRMClock = 0;
        }   
    
    DRMLOG( _L( "CDRMClockServer::~" ) );
    }

// -----------------------------------------------------------------------------
// CDRMClockServer::RunErrorL
// From CActive. Complete the request and restart the scheduler.
// -----------------------------------------------------------------------------
//
TInt CDRMClockServer::RunError( TInt aError ) 
    {
    DRMLOG2( _L( "CDRMClockServer::RunError: %d" ), aError );

    // Inform the client.
    Message().Complete( aError );
    
    // Restart the scheduler.
    ReStart();
    
    // Error handled.
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CDRMClockServer::NewSessionL
// Called when a client requires a new instance.
// -----------------------------------------------------------------------------
CSession2* CDRMClockServer::NewSessionL( 
    const TVersion& aVersion,
    const RMessage2& /*aMessage*/ ) const 
    {
    DRMLOG( _L( "CDRMClockServer::NewSessionL" ) );
    
    // Check that the versions are compatible.
    if ( ! User::QueryVersionSupported( TVersion( KServerMajorVersion,
                                                  KServerMinorVersion,
                                                  KServerBuildVersion ), 
                                        aVersion ) ) 
        {
        // Sorry, no can do.
        User::Leave( KErrNotSupported );
        }
    
    DRMLOG( _L( "CDRMClockServer::NewSessionL: Creating a new session" ) );
    
    return CDRMClockSession::NewL( iDRMClock );    
    }


// -----------------------------------------------------------------------------
// CDRMClockServer::CDRMClockServer
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CDRMClockServer::CDRMClockServer() : 
    CServer2( EPriorityStandard )
    {
    // Nothing
    }
    
// -----------------------------------------------------------------------------
// CDRMClockServer::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CDRMClockServer::ConstructL() 
    {
    DRMLOG( _L( "CDRMClockServer::ConstructL" ) );

    // Ignore errors
    User::LeaveIfError( User::RenameThread( KClockThread ) );

    iDRMClock = CDRMClock::NewL();
    
    DRMLOG( _L( "CDRMClockServer::clock Server started." ) );
    
    // Add the server to the scheduler.
    StartL( DRMClock::KServerName );
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================
// -----------------------------------------------------------------------------
// Function StartupClock().
// This function starts the actual DRM Notifier
// the cleanup stack and active scheduler.
// Returns: TInt: Symbian OS error code.
// -----------------------------------------------------------------------------
//

TInt StartupClock( TAny* ) 
    {
    DRMLOG( _L( "unipertar.exe: StartupClock" ) );
    TInt error = KErrNone;
    CTrapCleanup* trap = CTrapCleanup::New();
    
    // Check that memory allocation was successful.
    __ASSERT_ALWAYS( trap, User::Invariant() );
    
    DRMLOG( _L( "unipertar.exe: StartupClock: active scheduler" ) );

    CActiveScheduler* scheduler = new CActiveScheduler();
    
    __ASSERT_ALWAYS( scheduler, User::Invariant() );
    
    CActiveScheduler::Install( scheduler );
    
    // Reusing semaphore
    RSemaphore clientSem;
    __ASSERT_ALWAYS( !( clientSem.OpenGlobal( KDRMEngCommonSemaphore ) ), 
        User::Invariant() );
    
    error = StartClockServer( clientSem );
    
    if ( error ) {
        // Server creation failed. Release the semaphore.
        // In case of successful startup, CDRMClockServer
        // releases the semaphore.
        clientSem.Signal();
        clientSem.Close();
        }
    
    delete scheduler; 
    scheduler = NULL;
    
    delete trap;
    trap = NULL;
    
    DRMLOG2( _L( "unipertar.exe: StartupClock exits with %d" ), error );
    
    return error;
    }

//  End of File