/*

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

 *      Server implementation for FlexTimerServerMonitor

 */

/*

 * %version: 2 %

 */

#include "flextimerservermonitorserver.h"

#include "flextimerservermonitorcommon.h"

#include "flextimerservermonitorsession.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "flextimerservermonitorserverTraces.h"

#endif

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

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

// Construction

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

//

EXPORT_C CFlexTimerServerMonitorServer* CFlexTimerServerMonitorServer::NewL(

    CActive::TPriority aPriority )

    {

    return new ( ELeave ) CFlexTimerServerMonitorServer( aPriority );

    }

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

// Destructor

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

//

CFlexTimerServerMonitorServer::~CFlexTimerServerMonitorServer()

    {

    iFlexTimer.Close();

    }

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

// Creation of new sessions, called by server framework

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

//

CSession2* CFlexTimerServerMonitorServer::NewSessionL( 

    const TVersion& aVersion ,

    const RMessage2& /* aMessage */ ) const

    {

    if ( aVersion.iMajor > KFlexTimerServerMonitorMajorVersionNumber )

        {

        User::Leave( KErrNotSupported );

        }

    // Create and return session

    return CFlexTimerServerMonitorSession::NewL();

    }

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

// Connect to FlexTimer service

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

//

TInt CFlexTimerServerMonitorServer::StartMonitoring()

    {

    if ( iIsMonitoringOn )

        {

        return KErrAlreadyExists;

        }

    iIsMonitoringOn = ETrue;

    return iFlexTimer.Connect();

    }

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

// Close connection to FlexTimer service

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

//

TInt CFlexTimerServerMonitorServer::StopMonitoring()

    {

    if ( !iIsMonitoringOn )

        {

        return KErrNotFound; 

        }

    iIsMonitoringOn = EFalse;

    iFlexTimer.Close();

    return KErrNone;

    }

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

// Get status of the monitored process

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

//

TInt CFlexTimerServerMonitorServer::GetStatus( TBool& aHasServerCrashed )

    {

    if ( !iIsMonitoringOn )

        {

        return KErrNotFound;

        }

    // Check has the FlexTimerServer crashed by trying to configure

    // the timer. If the server has crashed, it fails. Usually, in case of

    // server crash this will return KErrServerTerminated (-15).

    TInt ret = iFlexTimer.Configure( TTimeIntervalMicroSeconds( 1000000 ) );

    if ( ret == KErrNone )

        { // No crash.

        aHasServerCrashed = EFalse;

        }

    else

        { // Crash has happened.

        aHasServerCrashed = ETrue;

        }

    return KErrNone;

    }

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

// Thread start function, loops in active scheduler

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

//

void CFlexTimerServerMonitorServer::StartServerL()

    {

    // Called when thread is created, create active scheduler

    CActiveScheduler* scheduler = new CActiveScheduler;

    User::LeaveIfNull( scheduler );

    // Add active scheduler object to cleanup stack before installing it.

    // It will be deleted, if any of the next operations fails.

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    // Create server object and start it

    CFlexTimerServerMonitorServer* server( NULL );

    server = CFlexTimerServerMonitorServer::NewL( EPriorityStandard );

    // Push the server object to cleanup stack before starting it

    CleanupStack::PushL( server );

    User::LeaveIfError( server->Start( KFlexTimerServerMonitorServerName ) );

    // Complete open rendezvous in this process (syncs with creator)

    RProcess::Rendezvous( KErrNone );

    // Active scheduler start will not leave, thus pop added objects

    // from the cleanup stack. They will be deleted once the execution

    // returns from the active scheduler (application is exiting)

    CleanupStack::Pop( server );

    CleanupStack::Pop( scheduler );

    // Start active scheduler, thread stays in active scheduler loop

    CActiveScheduler::Start();

    // Delete allocated resources

    delete server;

    delete scheduler;

    }

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

// Constructor

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

//

CFlexTimerServerMonitorServer::CFlexTimerServerMonitorServer( 

    CActive::TPriority aPriority ) :

    CServer2( aPriority ), iIsMonitoringOn( EFalse )

    {

    }

// ======== GLOBAL FUNCTIONS ========

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

// Main function of the server executable.

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

//

GLDEF_C TInt E32Main()

    {

    // Mark memory allocation check 

    __UHEAP_MARK;

    // Create cleanup stack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    __ASSERT_ALWAYS(

        cleanup != NULL, 

        User::Panic( KFlexTimerServerMonitorPanicCategory, 

                     ECleanupStackCreationFailed ) );

    // Start server

    TRAPD( panicCode, CFlexTimerServerMonitorServer::StartServerL() );

    delete cleanup;

    if ( panicCode != KErrNone )

        {

        User::Panic( KFlexTimerServerMonitorPanicCategory, panicCode );

        }

    // Memory allocation check, panic in UDEB case of memory leak

    __UHEAP_MARKEND;

    return KErrNone;

    }