// Copyright (c) 2006-2009 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:

//

// INCLUDE FILES

#include "HWRMServer.h"

#include "HWRMServerActiveScheduler.h"

#include "HWRMConfiguration.h"  

#include "HWRMtrace.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

TInt E32Main(void); // Process entry point

// FORWARD DECLARATIONS

// None

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

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

// Function that starts the HWRMServer.

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

//

static TInt RunServer()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - RunServer()" ));

    RSemaphore startLock;

    CHWRMServerActiveScheduler* scheduler = NULL;

    CHWRMServer* server = NULL;

    // Create lock

    TInt err = startLock.CreateGlobal( KServerSemaphoreName, 1, EOwnerProcess );

    if ( err == KErrAlreadyExists )

        {

        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Semaphore already exists, opening existing one." ));

        err = startLock.OpenGlobal( KServerSemaphoreName );

        }

    else

        {

        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Created a new semaphore." ));

        }

    // If there is error, server doesn't need to be started as it is either

    // very recently started (i.e. semaphore doesn't exist anymore even though creating it failed)

    // or there is something very wrong in system.

    if ( err == KErrNone )

        {

        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Waiting on a semaphore." ));

        startLock.Wait();

        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Semaphore wait over." ));

        // Check if HWRMServer process is already running.  

        TFindProcess processFinder(KServerFindPattern);

        TFullName processName;       

        err = processFinder.Next( processName );

        COMPONENT_TRACE2(_L( "HWRM Server - RunServer() - Process find result: %d." ), err);

        // If HWRMServer process is not yet running, properly start it

        if ( err == KErrNotFound )

            {

            // Naming the server process and thread after the startup helps to debug panics

            TInt renameErr1 = User::RenameProcess(KServerProcessName);

            if (renameErr1 != KErrNone)

            	{

            	COMPONENT_TRACE2(_L( "HWRM Server - RunServer() - Error %d renaming server process" ), renameErr1);

            	}

            TInt renameErr2 = User::RenameThread(KServerProcessName);

            if (renameErr2 != KErrNone)

            	{

            	COMPONENT_TRACE2(_L( "HWRM Server - RunServer() - Error %d renaming server thread" ), renameErr2);

            	}

            // Create and install the active scheduler we need

            if ( ( renameErr1 == KErrNone ) && (renameErr2 == KErrNone) )

                {

                TRAP( err, scheduler = CHWRMServerActiveScheduler::NewL() );

                // Note: Cannot use leaves and cleanupStack to reduce ifs here, because semaphore needs to be signaled in any case.

                if ( err == KErrNone )

                    {

                    CActiveScheduler::Install( scheduler );

                    // Now we are ready to instantiate the actual CHWRMServer instance

                    TRAP( err, server = CHWRMServer::NewL( KServerCActivePriority ) );

                    if ( err == KErrNone )

                        {

                    	// Initialisation complete, now signal the client

                    	RProcess::Rendezvous(KErrNone);

                        // Server is now up and running, so signal semaphore

                        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Signaling semaphore." ));

                        startLock.Signal();

                        startLock.Close(); // close already here to delete unnecessary reference

                    	// Ready to run

                        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Starting scheduler..." ));

                    	CActiveScheduler::Start();

                        COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - Scheduler stopped" ));

                        }

                    }

                }

            // In case there was any error, signal the semaphore as it has not been yet signaled

            if ( ( err != KErrNone ) || ( renameErr1 != KErrNone ) || ( renameErr2 != KErrNone ) )

                {

                COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - error occurred - signaling semaphore." ) );

                startLock.Signal();

                // make sure we return an error code if there was an error

                if (err == KErrNone)

                	{

                	err = (renameErr1 == KErrNone) ? renameErr2 : renameErr1;

                	}

                }

            }

        else // Probably KErrNone

            {

            // Already running, do not restart

            COMPONENT_TRACE1(_L( "HWRM Server - RunServer() - HWRM Server already started, signaling semaphore" ) );

            startLock.Signal();

            }

        }

    else

        {

        COMPONENT_TRACE2(_L( "HWRM Server - RunServer() - Problems opening startup semaphore: %d." ), err);

        }

    // Cleanup

    startLock.Close();

    delete server;

    delete scheduler;

    COMPONENT_TRACE2(_L( "HWRM Server - RunServer() - return %d" ), err);

    return err;

    }

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

// Main function

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

//

TInt E32Main()

    {

    COMPONENT_TRACE1(_L( "HWRM Server - E32Main()" ));

	__UHEAP_MARK;

  	TInt ret(KErrNone);

    // No process with same name found, start server.

	CTrapCleanup* cleanup = CTrapCleanup::New();

	ret = KErrNoMemory;

	if ( cleanup )

		{

		ret = RunServer();

		delete cleanup;

		}

	__UHEAP_MARKEND;

    COMPONENT_TRACE2(_L( "HWRM Server - E32Main - return %d" ), ret );

	return ret;

    }

//  End of File