/*

* 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 CSettingServer 

* class member functions.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32svr.h>

#include "SettingServerClient.h"

#include "SettingServer.h"

#include <StifParser.h>

#include "STIFTestFrameworkSettings.h"

#include "Logging.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// None

#undef LOGGER

#define LOGGER iSettingServer->Logger()

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

/*

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

    Class: CLoggerSetting

    Method: NewL

    Description: Create new CLoggerSetting (Setting server session)

    Parameters: RThread& aClient: in: Handle to thread client

                CSettingServer* aServer: in: Pointer to CSettingServer

    Return Values: CLoggerSetting* Pointer to new CLoggerSetting

    Errors/Exceptions: Leaves if memory allocation fails or ConstructL leaves.

    Status: Proposal

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

*/

CLoggerSetting* CLoggerSetting::NewL( CSettingServer* aServer )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aServer );

    CleanupStack::Pop();

    return self;

    }

/*

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

    Class: CLoggerSetting

    Method: CLoggerSetting

    Description: Constructor. Initialise base class.

    Parameters: RThread& aClient: in: Handle to client

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CLoggerSetting::CLoggerSetting() :

        CSession2()

    {

    }

/*

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

    Class: CLoggerSetting

    Method: ~CLoggerSetting

    Description: Destructor.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

CLoggerSetting::~CLoggerSetting()

    {

    }

/*

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

    Class: CLoggerSetting

    Method: ConstructL

    Description: Second level constructor.

    Parameters: CSettingServer* aServer: in: Server

    Return Values: None

    Errors/Exceptions: Leaves if base class CreateL leaves

    Status: Proposal

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

*/

void CLoggerSetting::ConstructL( CSettingServer* aServer )

    {

    // @spe __TRACE( KInit,( _L( "CLoggerSetting::ConstructL - constructing server session" ) ) );

    iSettingServer = aServer;

    // second-phase construct base class

    //CSession2::CreateL();

//    iSettingServer = aServer;

     // Inform server class that session is opening. 

    iSettingServer->OpenSession();    

    __TRACE( KInit,( _L( "CLoggerSetting::ConstructL - constructing server session done" ) ) );

    }

/*

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

    Class: CLoggerSetting

    Method: PanicClient

    Description: Panic clients.

    Parameters: TInt aPanic: in: Panic code

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CLoggerSetting::PanicClient( const TInt aPanic, const RMessage2& aMessage ) const

    {

    __TRACE( KError,( _L( "CLoggerSetting::PanicClient code = %d" ), aPanic ) );

    _LIT( KTxtModule,"CLoggerSetting" );

    aMessage.Panic( KTxtModule,aPanic );

    }

/*

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

    Class: CLoggerSetting

    Method: CloseSession

    Description: Close session

    Parameters: const RMessage&: out: Message to be completed.

    Return Values: TInt: Always KErrNone

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CLoggerSetting::CloseSession( /*const RMessage& aMessage*/ )

    {

    __TRACE( KVerbose,( _L( "CLoggerSetting::CloseSession in" ) ) );

    // Close session from server (and stop it if required)

    iSettingServer->CloseSession();

    // NOTE: This complete will make after DispatchMessageL in ServiceL method.

    // Complete message. This must be done after possible closing

    // of the server to make sure that server is first closed before

    // client can send new messages.

    // aMessage.Complete( KErrNone );

    __TRACE( KVerbose,( _L( "CLoggerSetting::CloseSession out" ) ) );

    return KErrNone;

    }

/*

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

    Class: CLoggerSetting

    Method: ServiceL

    Description: Trap harness for dispatcher

    Parameters: const RMessage& aMessage: inout: Message

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

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

*/

void CLoggerSetting::ServiceL( const RMessage2& aMessage )

    {

    __TRACE( KVerbose,( _L( "CLoggerSetting::ServiceL in" ) ) );

    TInt r( KErrNone );

    TBool isMessageSync( EFalse );

    TRAPD( ret, r = DispatchMessageL( aMessage, isMessageSync ) );

    if( ret != KErrNone )

        {

        // Complete message on leaving cases with leave code allways.

        __TRACE( KError,( _L( "CLoggerSetting::DispatchMessageL leaved" ) ) );

        aMessage.Complete( ret );

        }

    else if( isMessageSync )

        {

        // Message is syncronous, Complete message with error code 

        // originating from message handling

         __TRACE( KVerbose,( _L( "CLoggerSetting::DispatchMessageL completed with: %d" ), r ) );

        aMessage.Complete( r );

        }

    __TRACE( KVerbose,( _L( "CLoggerSetting::ServiceL out" ) ) );

    }

/*

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

    Class: CLoggerSetting

    Method: DispatchMessageL

    Description: Dispatch message, calls corresponding function to do it.

    Parameters: const RMessage& aMessage: inout: Message to be handled

                TBool& aIsMessageSync: inout: Indication of the message type

    Return Values: TInt: Error code

    Errors/Exceptions: Leaves if operation handling function leaves

    Status: Proposal

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

*/

TInt CLoggerSetting::DispatchMessageL( const RMessage2& aMessage,

                                        TBool& aIsMessageSync )

    {

    __TRACE( KInit ,( _L( "CLoggerSetting::DispatchMessageL in" ) ) );

    switch( aMessage.Function() )

        {

        case ESettingServerCloseSession: 

            {

            __TRACE( KInit ,( _L( "Closing Setting server session" ) ) );

            aIsMessageSync = ETrue;

            return CloseSession( /*aMessage*/ );

            }

        case ESetIniFileInformation:

            {

            __TRACE( KInit ,( _L( "Set initialization file setting" ) ) );

            aIsMessageSync = ETrue;

            return SetIniFileSettings( aMessage );

            }

        case EReadLoggerSettingsFromIniFile:

            {

            __TRACE( KInit ,( _L( "Read Logger setting(s) from initialization file" ) ) );

            aIsMessageSync = ETrue;

            return ReadLoggerSettingsFromIniFile( aMessage );

            }

        case EGetLoggerSettings:

            {

            __TRACE( KInit ,( _L( "Get Logger setting(s)" ) ) );

            aIsMessageSync = ETrue;

            return GetLoggerSettings( aMessage );

            }

        case ESetNewIniFileSetting:

            {

            __TRACE( KInit ,( _L( "Set new initialization file setting" ) ) );

            aIsMessageSync = ETrue;

            return SetNewIniFileSetting( aMessage );

            }

        case EGetEngineSettings:

            {

            __TRACE(KInit, (_L("Get Engine settings")));

            aIsMessageSync = ETrue;

            return GetEngineSettings(aMessage);

            }

        case EStoreEngineSettings:

            {

            __TRACE(KInit, (_L("Store Engine settings")));

            aIsMessageSync = ETrue;

            return StoreEngineSettings(aMessage);

            }

         // Invalid request

        default:

            {

            PanicClient( EBadRequest, aMessage );

            return KErrNotSupported;

            }

        }

    }

/*

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

    Class: CSettingServer

    Method: SetIniFileSettings

    Description: Set initialization filename and path settings to Setting

                 server.

    Parameters: const RMessage& aMessage: inout: Message to be handled

    Return Values: TInt: Symbian error code

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CLoggerSetting::SetIniFileSettings( const RMessage2& aMessage )

    {

    __TRACE( KInit, ( _L( "CLoggerSetting::SetIniFileSettings" ) ) );

    // Get data from message

    TFileName iniFile;

    // Get length from message param 1

    // Read data from client descriptor (param 0)

    TRAPD( ret, aMessage.ReadL( 0, iniFile ) );

    if ( ret != KErrNone )

        {

        PanicClient( EBadDescriptor, aMessage );

        return KErrBadDescriptor;

        }

    // Inifile name and path information

    iSettingServer->iIniFile = iniFile;

    __TRACE( KInit, ( _L( "New initialization file: [%S]" ), &iSettingServer->iIniFile ) );

    return KErrNone;

    }

/*

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

    Class: CSettingServer

    Method: ReadLoggerSettingsFromIniFile

    Description: Read Logger setting from initialization file. Mainly use from

                 TestEngine side.

    Parameters: const RMessage& aMessage: inout: Message to be handled

    Return Values: TInt: Symbian error code

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CLoggerSetting::ReadLoggerSettingsFromIniFile( const RMessage2& aMessage )

    {

    __TRACE( KInit, ( _L( "CLoggerSetting::ReadLoggerSettingsFromIniFile" ) ) );

    TInt ret = ReadLoggerDefaults();

    if( ret != KErrNone )

        {

        return ret;

        }

    // Copies logger settings to the package

    TPckg<TLoggerSettings> loggerSettingsPckg( iSettingServer->iLoggerSettings );

    // Writes a packege that includes the logger overwrite settings to aMessage

    TRAPD( err, aMessage.WriteL( 0, loggerSettingsPckg ) );

    if ( err != KErrNone )

        {

        PanicClient( EBadDescriptor, aMessage );

        }

    return KErrNone;

    }

/*

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

    Class: CLoggerSetting

    Method: ReadLoggerDefaults

    Description: Parse Logger defaults from STIF initialization

                 file.

    Parameters: None

    Return Values: TInt: Return Symbian error code

    Errors/Exceptions: None

    Status: Proposal

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

*/

TInt CLoggerSetting::ReadLoggerDefaults()

    {

    __TRACE( KInit,( _L( "" ) ) );

    __TRACE( KInit,( _L( "CLoggerSetting::ReadLoggerDefaults" ) ) );

    __TRACE( KInit,( _L( "Start reading and parsing Logger defaults" ) ) );

    TInt ret = KErrNone;

    // Create parser for parsing ini file

    CStifParser* parser = NULL;

    TRAPD( r, parser = CStifParser::NewL( _L(""), iSettingServer->iIniFile ) );

    if ( r != KErrNone )

        {

        __TRACE( KError,( CStifLogger::ERed, _L( "Can't open ini-file [%S], code %d" ), &iSettingServer->iIniFile, r ) );

        return r;

        }

    CSTIFTestFrameworkSettings* settings = NULL;

    TRAPD( settings_ret, settings = CSTIFTestFrameworkSettings::NewL() );

    if ( settings_ret != KErrNone )

        {

        __TRACE( KError,( CStifLogger::ERed, _L( "CSTIFTestFrameworkSettings class object creation fails") ) );

        return settings_ret;

        }

    TInt get_ret( KErrNone );

    CStifSectionParser* sectionParser = NULL;

    // Parse Logger's overwrite values

    _LIT( KDefaultsStart, "[Logger_Defaults]" );

    _LIT( KDefaultsEnd, "[End_Logger_Defaults]" );

    __TRACE( KInit,( _L( "Starting to search sections" ) ) );

    TRAP( r,

        sectionParser = parser->SectionL( KDefaultsStart, KDefaultsEnd );

        );

    // Get directory settings

    if ( ( r == KErrNone ) && sectionParser )

        {

        __TRACE( KInit,( _L( "Found '%S' and '%S' sections" ), &KDefaultsStart, &KDefaultsEnd ) );

        __TRACE( KInit,( _L( "Parsing Logger directory indicator" ) ) );

        TBool createDir( EFalse );

        TRAP( get_ret,

            get_ret = settings->GetBooleanSettingsL( sectionParser,

                                _L( "CreateLogDirectories=" ), createDir );

            );

        if ( get_ret == KErrNone )

            {

            __TRACE( KInit,( _L( "Logger directory indicator: %d"), createDir ) );

            iSettingServer->iLoggerSettings.iCreateLogDirectories = createDir;

            iSettingServer->iLoggerSettings.iIsDefined.iCreateLogDir = ETrue;

            }

        else

            {

            __TRACE( KInit,( _L( "Indicator not found or not given" ) ) );

            }

        // Get Logger path settings