/*

* Copyright (c) 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: This module contains implementation of RTestServer, 

* RTestModule and RTestExecution class member functions.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <stifinternal/TestServerClient.h>

#include "TestServerCommon.h"

//--PYTHON-- begin

#include "StifPython.h"

//--PYTHON-- end

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// None

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

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: RTestServer

    Description: Default constructor

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

    might leave.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

EXPORT_C RTestServer::RTestServer()

    {

    }

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: Connect

    Description: Connect method creates new RTestServer session.

    RTestServer session is used to manage the test case execution.

    Parameters: const TFileName& aModuleName: in: Module to be loaded

                const TDesC& aConfigFile: in: Test case(config) file

                name(Used in TestScripter case for parsing STIF settings).

    Return Values: TInt Error code

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------

*/

EXPORT_C TInt RTestServer::Connect( const TFileName& aModuleName,

                                    const TDesC& aConfigFile

                                    )

    {

    TFileName serverName;

    TInt ret = KErrNone;

    // Create global semaphore start-up. It will be indexed (if given name already exsists, index will be increased)

    RSemaphore startSemaphore;

    TName semaphoreName = _L("startupSemaphore");

    semaphoreName.Append( aModuleName );

    TInt x = 0;

    RBuf semName;

    ret = semName.Create(KMaxName);

    if(ret != KErrNone)

        {

        RDebug::Print(_L("RTestServer::Connect() Could not create buffer for semaphore name [%d]"), ret);

        return ret;

        }

    do

        {

        semName.Format(_L("%S%d"), &semaphoreName, x);

        ret = startSemaphore.CreateGlobal(semName, 0);

        RDebug::Print(_L("RTestServer::Connect() Creating global semaphore [%S] with result [%d]"), &semName, ret);

        if(ret != KErrAlreadyExists)

            {

            semaphoreName.Copy(semName);

            break;

            }

        x++;

        } while (ETrue);

    semName.Close();

    if ( ret != KErrNone )

        {

        startSemaphore.Close();

        return ret;

        }

    // By default start 'testserverstarter.exe'

    TFileName pathAndExeModule;

    if ( aModuleName.Find( _L( "testscripter_ui_" ) ) == 0 ) 

    	{

        pathAndExeModule.Copy( KDefaultUiExeName );    	

    	}

    else

    	{

        pathAndExeModule.Copy( KDefaultExeName );    	

    	}

    RProcess pr;

    // Data to be passed to new process. It will contain module name and synchronization semaphore name separated with space.

    // I.e. it will be: "mymodule startupSemaphore0"

    RBuf data; 

    ret = data.Create(KMaxName);

    if(ret != KErrNone)

        {

        RDebug::Print(_L("RTestServer::Connect() Could not create buffer for data to be passed to process [%d]"), ret);

        return ret;

        }

    data.Format(_L("%S %S"), &aModuleName, &semaphoreName);

    RDebug::Print(_L("RTestServer::Connect() Data for new process prepared [%S]"), &data);

    // Indication is Create() operation needed

    TBool doCreate( ETrue );

    #ifdef __WINS__ // CodeWarrior(emulator)

        // Create without path(Uses Symbian default path).

        // Note: If TestScriter used then module name is format:

        // testscripter_testcasefilename

        ret = pr.Create( aModuleName, data );

        if( ret == KErrNone )

            {

            RDebug::Print(_L("RTestServer::Connect() Combination (1): Caps modifier [%S], Data [%S]"), &aModuleName, &data);

            doCreate = EFalse;

            }

    #endif // __WINS__

    if ( doCreate )

        {

        TInt find_ret( KErrNone );

        TInt trapd_ret( KErrNone );

        // Check is TestScripter and is caps modifíer name given

        if( aModuleName.Find( KTestScripterName ) != KErrNotFound && aConfigFile != KNullDesC )

            {

            TInt ret_caps;

            TFileName capsModifierName;

            // In TestClass's test case (config) file can give name to caps

            // modifier module.

            ret_caps = GetCapsModifier( aConfigFile, capsModifierName );

            if( ret_caps != KErrNone )

                {

                RDebug::Print( _L( "RTestServer::Connect() Caps modifier was not defined. Default modifier will be used" ) );

                }

            else

                {

                #ifdef __WINS__ // CodeWarrior(emulator)

                    // Create without path(Uses Symbian default path)

                    ret = pr.Create( capsModifierName, data );

                    if( ret == KErrNone )

                        {

                        RDebug::Print( _L( "RTestServer::Connect() Combination (2): Caps modifier [%S], Data [%S]"), &capsModifierName, &data);

                        doCreate = EFalse;

                        }

                #endif // __WINS__

                if ( doCreate )

                    {

                    TRAP( trapd_ret, find_ret = FindExeL(

                                    capsModifierName, pathAndExeModule ) );

                    }

                }

            }

        //--PYTHON-- begin

        // If this is python module, use caps modifier

        else if(aModuleName.Length() >= KPythonScripterLength && aModuleName.Mid(0, KPythonScripterLength).Compare(KPythonScripter) == 0)

           {

           pathAndExeModule.Copy(KPythonScripter);

           }

        //--PYTHON-- end

        // Find exe from file system

        else if( aModuleName != _L( "testcombiner" ) )

           {

           // Check if e.g. TestModule.exe is available

           TRAP( trapd_ret, find_ret = FindExeL( aModuleName, pathAndExeModule  ) );

           }

        // Check FindExeL error codes

        if( find_ret != KErrNone )

			{

			// Module was not found, using default exe: testserverstarter.exe

			RDebug::Print( _L( "RTestServer::Connect() Correct caps modifier module not found, capabilities cannot set" ) );

			if ( aModuleName.Find( _L( "testscripter_ui_" ) ) == 0 ) 

				{

				pathAndExeModule.Copy( KDefaultUiExeName );    	

				}

			else

				{

				pathAndExeModule.Copy( KDefaultExeName );    	

				}           

			}

        if( trapd_ret != KErrNone )

           {

           // FindExeL fails

           RDebug::Print( _L( "RTestServer::Connect() Caps modifier module searching fails with error: %d" ), trapd_ret );

           startSemaphore.Close();

           data.Close();

           return trapd_ret;

           }

        }

    if ( doCreate )

        {

        ret = pr.Create( pathAndExeModule, data );

        RDebug::Print(

            _L( "RTestServer::Connect() Combination (3): Caps modifier [%S], Data [%S], Result [%d]" ),

            &pathAndExeModule, &data, ret );

        }

    data.Close();

    if ( ret != KErrNone )

        {

        startSemaphore.Close();  

        return ret;

        }

    // Process created, continue start-up

    pr.Resume();

    pr.Close();

    // Wait until server is started

    startSemaphore.Wait();

    startSemaphore.Close();     // Close semaphore

    serverName = aModuleName;

    // Server is up and running, connect to it    

    ret = CreateSession( serverName, Version() );    

    return ret;

    }

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: Version

    Description: Return client side version.

    Parameters: None

    Return Values: TVersion: Version number

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

EXPORT_C TVersion RTestServer::Version() const

    {

    return( TVersion( KTestServerMajorVersionNumber,

                       KTestServerMinorVersionNumber, 

                       KTestServerBuildVersionNumber 

                     ) );

    }

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: Close

    Description: Closes the RTestServer session.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

EXPORT_C void RTestServer::Close()

    {

    // Check that server is connected

    if( Handle() != 0 )

        {

        TIpcArgs args( TIpcArgs::ENothing, TIpcArgs::ENothing, TIpcArgs::ENothing );

        SendReceive( ETestServerCloseSession, args );

        }

    RSessionBase::Close();

    }

 /*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: GetServerThreadId

    Description: Get server thread id

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

EXPORT_C TInt RTestServer::GetServerThreadId(TThreadId& aThreadId)

    {

    TInt ret(0);

    // Check that server is connected

    if( Handle() != 0 )

        {

        TThreadId id;

        TPckg<TThreadId> threadIdPckg( id );

        TIpcArgs args( &threadIdPckg, TIpcArgs::ENothing, TIpcArgs::ENothing );

        ret = SendReceive( ETestServerGetServerThreadId, args );  

        aThreadId = threadIdPckg();        

        }

    return ret;

    }            

EXPORT_C TInt RTestServer::PassEngineSessionSettings( const TEngineSettings& aEngineSessionSettings )

    {

    TPckgC<TEngineSettings> engineSessionSettingsBuf( aEngineSessionSettings );    

    return SendReceive( ETestServerPassEngineSessionSettings, 

            TIpcArgs( &engineSessionSettingsBuf ) );

    }

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: FindExeL

    Description: Find exe(CapsModifier) from file system(Used in EKA2)

    Parameters: TFileName aModuleName: in: Module name.

                TFileName& aPathAndExeModule: inout: Module's exe(CapsModifier)

                path information.

    Return Values: TBool: Symbian error code: If exe(CapsModifier) is found

                          return KErrNone else other error code will return.

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------

*/

TBool RTestServer::FindExeL( TFileName aModuleName,

                                TFileName& aPathAndExeModule )

    {

    RFs fsSession;  // For the file session handling

    RFile file;

    // Connect to file server

	User::LeaveIfError( fsSession.Connect() ); // Start session

    TDriveList drivelist; 

	User::LeaveIfError( fsSession.DriveList(drivelist) );

	// A TDriveList (the list of available drives), is an array of 

	// 26 bytes. Each byte with a non zero value signifies that the 

	// corresponding drive is available.

    TInt driveNumber; 

	TChar driveLetter;

	for( driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++ )

		{

		if( !drivelist[driveNumber] ) 

			{

			// If drive-list entry is zero, drive is not available

			continue;

			}

        User::LeaveIfError(fsSession.DriveToChar(driveNumber,driveLetter));

        aPathAndExeModule.Zero();

        aPathAndExeModule.Append( driveLetter );

        aPathAndExeModule.Append( _L(":\\sys\\bin\\") );

        aPathAndExeModule.Append( aModuleName );

        aPathAndExeModule.Append( _L( ".exe" ) );

        TInt found( KErrNone );

        found = file.Open( fsSession, aPathAndExeModule, EFileRead );

        if( found == KErrNone )

            {

            // exe(capsmodifier module) is founded.

            file.Close();

            fsSession.Close();

            return KErrNone;

            }

        }

    // If exe not found use testserverstarter.exe but capabilities cannot

    // set.

    if ( aModuleName.Find( _L( "testscripter_ui_" ) ) == 0 ) 

    	{

        aPathAndExeModule.Copy( KDefaultUiExeName );    	

    	}

    else

    	{

        aPathAndExeModule.Copy( KDefaultExeName );    	

    	}	

    file.Close();

    fsSession.Close();

    return KErrNotFound;

    }

/*

-------------------------------------------------------------------------------

    Class: RTestServer

    Method: GetCapsModifierName

    Description: Get caps modifier module name from TestScripter's test

                 case(config) file.

    Parameters: const TDesC& aConfigFile: in: TestScripter's test case(config)

                file path and name.

                TFileName& aCapsModifierName: inout: Parsed caps modifier name.

    Return Values: TInt: Symbian error code: Return KErrNone if caps modifier

                                             module name is successfully parsed

                                             or given else other error code

                                             will return.

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------

*/

TInt RTestServer::GetCapsModifier( const TDesC& aConfigFile,

                                        TFileName& aCapsModifierName )

    {

    // Create parser

    CStifParser* parser = NULL;

    TRAPD( err, parser = CStifParser::NewL( _L(""), aConfigFile ) );

    if( err != KErrNone )

        {

        return err;

        }

    CleanupStack::PushL( parser );

    // Create section

    CStifSectionParser* section = NULL;

    TRAP( err, section = parser->SectionL( KStifSettingsStartTag,

                                            KStifSettingsEndTag ) );

    if( err != KErrNone || section == NULL)

        {

        CleanupStack::PopAndDestroy( parser );

        return KErrNotFound;

        }

    CleanupStack::PushL( section );

    // Create item