/*

* 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:  DRM3 Engine manages all DRM related database operations.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "DRMNotifierServer.h"

#include "drmnotifierclientserver.h"

#include "drmcommonclientserver.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

#define _LOGBUFNUM( a, b )

#define LOGBUFNUM( a, b )

#define LOG( a )

// LOCAL CONSTANTS AND MACROS

LOCAL_C const TUint8 KMaxStartTries = 5;

LOCAL_C const TInt KWaitingTime = 1000000; // 10 secs

_LIT( KNotifierThread, "drmnotifier" );

// MODULE DATA STRUCTURES

using DRMNotifier::KServerMajorVersion;

using DRMNotifier::KServerMinorVersion;

using DRMNotifier::KServerBuildVersion;

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt StartNotifierServer( RSemaphore& aClientSem );

// FORWARD DECLARATIONS

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

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

// Function StartNotifierServer().

// 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.

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

TInt StartNotifierServer( RSemaphore& aClientSem ) 

    {

    TInt error = KErrNone;

    CDRMNotifierServer* server = NULL;

    TUint8 count = 0;

#ifdef _DRM_TESTING

    TTime time;

    _LIT8( KDRMErrorDebugText, "Error: " );

    RFs fs;

    RFile file;

    TFileName filename;

    time.UniversalTime();

    TRAPD( error2, time.FormatL( filename, KDateTimeFormat ) );

    filename.Append( _L( "DRMNotifier.txt " ) );

    error = fs.Connect();

    if ( error )

        {

        return error;

        }

    file.Replace( fs, filename, EFileStreamText | EFileWrite );

    file.Write( _L8( "Started." ) );

#endif

    do 

    {

       _LOGBUFNUM( KDRMErrorDebugText, error );

       ++count;

       TRAP( error, ( server = CDRMNotifierServer::NewL() ) );

       if ( error ) 

       {

          User::After( TTimeIntervalMicroSeconds32(KWaitingTime) );

       }

    } while( error && ( count <= KMaxStartTries ) );

    if( error ) 

    {

#ifdef _DRM_TESTING

       _LOGBUFNUM( _L8( "Failed: " ), error );

        file.Close();

        fs.Close();

#endif

        // Failed

        return error;

        }

#ifdef _DRM_TESTING

    file.Write( _L8( "OK!" ) );

    file.Close();

    fs.Close();

#endif

#ifdef __WINS__

    //UserSvr::ServerStarted();

#endif        

    // Release the semaphore...

    aClientSem.Signal();

    aClientSem.Close();

    // Start waiting for connections

    CActiveScheduler::Start();

    // Dying.

    // Delete CDRMRigntsServer

    delete server;

    return KErrNone;

    }

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

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

// CDRMNotifierServer::NewLC

// Two-phased constructor.

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

//

CDRMNotifierServer* CDRMNotifierServer::NewL()

    {

    CDRMNotifierServer* self = new( ELeave ) CDRMNotifierServer();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

CDRMNotifierServer::~CDRMNotifierServer() 

    {

    if( iStorage )

        {

        delete iStorage;

        iStorage = 0;

        }   

    LOG( _L8( "Dying..." ) );

#ifdef _DRM_TESTING

    delete iLog;

#endif

    }

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

// CDRMNotifierServer::RunErrorL

// From CActive. Complete the request and restart the scheduler.

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

//

TInt CDRMNotifierServer::RunError( TInt aError ) 

    {

    // Inform the client.

    Message().Complete( aError );

    // Restart the scheduler.

    ReStart();

    // Error handled.

    return KErrNone;

    }

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

// CDRMNotifierServer::NewSessionL

// Called when a client requires a new instance.

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

CSession2* CDRMNotifierServer::NewSessionL(

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/) const

    {

    RThread client;

    LOG( _L8( "NewSessionL" ) );

    // Check that the versions are compatible.

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

                                                  KServerMinorVersion,

                                                  KServerBuildVersion ), 

                                        aVersion ) ) 

        {

        // Sorry, no can do.

        User::Leave( KErrNotSupported );

        }

    LOG( _L8( "NewSessionL: Creating a new session" ) );

    return CDRMNotifierSession::NewL( iStorage );

    }

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

// CDRMNotifierServer::CDRMNotifierServer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CDRMNotifierServer::CDRMNotifierServer() : 

    CServer2( EPriorityStandard )

    {

    // Nothing

    }

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

// CDRMNotifierServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDRMNotifierServer::ConstructL() 

    {

    RFs fs;

    // Ignore errors

    User::RenameThread( KNotifierThread );

    User::LeaveIfError( fs.Connect() );

    fs.Close();

#ifdef _DRM_TESTING

    _LIT( KLogFile, "notifier.txt" );

    TFileName logFile( KLogFile );

    TTime time;

    time.UniversalTime();

    time.FormatL( logFile, KDateTimeFormat );

    logFile.Append( KLogFile );

    iLog = CLogFile::NewL( logFile, ETrue );

    iLog->SetAutoFlush( ETrue );

    iLog->SetAutoNewline( ETrue );

    LOG( _L8( "DRM Server starting..." ) );

#endif

    iStorage = CDRMMessageStorage::NewL();

    LOG( _L8( "Notification Server started." ) );

    // Add the server to the scheduler.

    StartL( DRMNotifier::KServerName );

    }

#ifdef _DRM_TESTING

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

// CDRMNotifierServer::Log

// Logging operation.

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

//

void CDRMNotifierServer::Log( const TDesC8& aLog ) const

    {

    iLog->Log( aLog );

    }

void CDRMNotifierServer::Log( const TDesC& aLog ) const

    {

    iLog->Log( aLog );

    }

#endif

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

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

// Function StartupNotifier().

// This function starts the actual DRM Notifier

// the cleanup stack and active scheduler.

// Returns: TInt: Symbian OS error code.

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

//

TInt StartupNotifier( TAny* ) 

    {

    TInt error = KErrNone;

    CTrapCleanup* trap = CTrapCleanup::New();

    // Check that memory allocation was successful.

    __ASSERT_ALWAYS( trap, User::Invariant() );

    CActiveScheduler* scheduler = new CActiveScheduler();

    __ASSERT_ALWAYS( scheduler, User::Invariant() );

    CActiveScheduler::Install( scheduler );

    RSemaphore clientSem;

    error = clientSem.OpenGlobal( KDRMEngCommonSemaphore );

    if( error ) 

        {

    	  return error;

        }

    error = StartNotifierServer( clientSem );

    if ( error ) {

        // If errors didn't occur, signal has been sent.

        clientSem.Signal();

        clientSem.Close();

        }

    delete scheduler; 

    scheduler = NULL;

    delete trap;

    trap = NULL;

    // __ASSERT_ALWAYS( !error, User::Invariant() );

    return KErrNone;

    }

//  End of File