/*

* 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:  Implements the functions to control STIF Test Framework

*                through the STIF TF interface.

*

*/

// INCLUDE FILES

#include <badesca.h>

#include <bautils.h>

#include <charconv.h>

#include <e32cons.h>

#include <HtiLogging.h>

#include "HtiStifTfIf.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const static TUid KStifTfServiceUid = { 0x10210CC3 };

enum TStifTfCommands

    {

    ECmdOpen            = 0x01,

    ECmdClose           = 0x02,

    ECmdLoadModule      = 0x03,

    ECmdUnloadModule    = 0x04,

    ECmdListCases       = 0x05,

    ECmdStartCase       = 0x06,

    ECmdCancelCase      = 0x07,

    ECmdPauseCase       = 0x08,

    ECmdResumeCase      = 0x09,

    ECmdAddCaseFile     = 0x0A,

    ECmdRemoveCaseFile  = 0x0B,

    ECmdCaseMsg         = 0x0C,

    ECmdSetDevId        = 0x0D,

    ECmdTestCompleted   = 0x0E,

    ECmdAtsMessage      = 0x0F,

    ECmdSetAttribute    = 0x10

    };

_LIT8( KParameterDelimiter, "|" );

// NOTE: Max length for error description is defined

// in HtiDispatcherInterface.h (currently 118).

_LIT8( KErrorStifTfNotOpen, "ERROR: STIF TF is not open" );

_LIT8( KErrorOpen, "ERROR: Failed to open STIF TF" );

_LIT8( KErrorAlreadyOpen, "ERROR: STIF TF is already open" );

_LIT8( KErrorClose, "ERROR: Failed to close STIF TF" );

_LIT8( KErrorUnknownCmd, "ERROR: Unknown STIF TF command" );

_LIT8( KErrorNoCmd, "ERROR: No command given" );

_LIT8( KErrorParameterMissing, "ERROR: Mandatory parameter missing" );

_LIT8( KErrorParameterTooLong, "ERROR: Parameter too long" );

_LIT8( KErrorTooManyParameters, "ERROR: Too many parameters" );

_LIT8( KErrorNoMemory, "ERROR: Memory allocation failure" );

_LIT8( KErrorLoadModule, "ERROR: Load Module failed" );

_LIT8( KErrorUnloadModule, "ERROR: Unload Module failed" );

_LIT8( KErrorInvalidCaseNumber, "ERROR: Invalid test case number parameter" );

_LIT8( KErrorModuleNotLoaded, "ERROR: Given test module is not loaded" );

_LIT8( KErrorGetTestCases, "ERROR: Failed to get test cases from module" );

_LIT8( KErrorGetTestCaseInfos, "ERROR: Failed to get test case infos" );

_LIT8( KErrorStartTestCase, "ERROR: Failed to start test case" );

_LIT8( KErrorCancelTestCase, "ERROR: Failed to cancel test case" );

_LIT8( KErrorPauseTestCase, "ERROR: Failed to pause test case" );

_LIT8( KErrorResumeTestCase, "ERROR: Failed to resume test case" );

_LIT8( KErrorInvalidDeviceId, "ERROR: Invalid device ID parameter" );

_LIT8( KErrorAddCaseFile, "ERROR: Add Case File failed" );

_LIT8( KErrorRemoveCaseFile, "ERROR: Remove Case File failed" );

_LIT8( KErrorFileServer, "ERROR: Failed to connect to file server" );

_LIT8( KErrorCaseFileNotFound, "ERROR: Given test case file was not found" );

_LIT8( KErrorIniFileNotFound, "ERROR: Given ini-file was not found" );

_LIT8( KErrorCaseMessage, "ERROR: Test case message sending failed" );

_LIT8( KErrorCharConv, "ERROR: Character conversion failed" );

_LIT8( KErrorInvalidAttributeId, "ERROR: Invalid attribute id parameter" );

_LIT8( KErrorSetAttribute, "ERROR: Failed to set attribute" );

_LIT8( KErrorUnknown, "ERROR: Unspecified error occured" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiStifTfIf::CHtiStifTfIf

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

// might leave.

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

//

CHtiStifTfIf::CHtiStifTfIf():iIsBusy( EFalse ),

                             iMessage( NULL ),

                             iErrorCode( 0 ),

                             iStifTfOpen( EFalse ),

                             iDevId( KDefaultDevId ),

                             iConsole( NULL )

    {

    }

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

// CHtiStifTfIf::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHtiStifTfIf::ConstructL( CHtiStifTfServicePlugin* aPlugin )

    {

    iCommandId = 0;

    iParameters = new (ELeave) CDesC8ArrayFlat( 5 );

    iPlugin = aPlugin;

    }

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

// CHtiStifTfIf::NewL

// Two-phased constructor.

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

//

CHtiStifTfIf* CHtiStifTfIf::NewL( CHtiStifTfServicePlugin* aPlugin )

    {

    CHtiStifTfIf* self = new( ELeave ) CHtiStifTfIf;

    CleanupStack::PushL( self );

    self->ConstructL( aPlugin );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHtiStifTfIf::~CHtiStifTfIf()

    {

    if ( iParameters )

        {

        iParameters->Reset();

        }

    delete iParameters;

    iLoadedInfos.ResetAndDestroy();

    iLoadedInfos.Close();

    delete iMessage;

    if ( iStifTfOpen ) Close();

    iPlugin = NULL;  // Not owned, so not deleted.

    iConsole = NULL; // Not owned, so not deleted.

    }

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

// CHtiStifTfIf::ProcessMessageL

// Interpretes the message and calls appropriate command handling method.

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

//

void CHtiStifTfIf::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/)

    {

    HTI_LOG_FUNC_IN( "CHtiStifTfIf::ProcessMessageL" );

    HTI_LOG_FORMAT( "Message length = %d", aMessage.Length() );

    if ( iIsBusy )

        {

        HTI_LOG_TEXT( "Plugin is busy - leaving" );

        User::Leave( KErrInUse );

        }

    iIsBusy = ETrue;

    if ( aMessage.Length() < 1 )

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrArgument, KErrorNoCmd ) );

        return;

        }

    iCommandId = aMessage[0];

    HTI_LOG_FORMAT( "Command = %d", iCommandId );

    TRAPD( err, ParseParametersL( aMessage ) );

    if ( err == KErrNoMemory )

        {

        User::LeaveIfError( SendErrorResponseMsg( err, KErrorNoMemory ) );

        return;

        }

    else if ( err )

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrGeneral, KErrorUnknown ) );

        return;

        }

    // If STIF TF is not open, any other command than OPEN returns KErrNotReady

    if ( !iStifTfOpen )

        {

        if ( iCommandId == ECmdOpen )

            {

            HandleOpenCmdL();

            return;

            }

        else

            {

            User::LeaveIfError(

                SendErrorResponseMsg( KErrNotReady, KErrorStifTfNotOpen ) );

            return;

            }

        }

    // Go through the rest of the commands

    if ( iCommandId == ECmdLoadModule )

        {

        HandleLoadModuleCmdL();

        }

    else if ( iCommandId == ECmdUnloadModule )

        {

        HandleUnloadModuleCmdL();

        }

    else if ( iCommandId == ECmdListCases )

        {

        HandleListCasesCmdL();

        }

    else if ( iCommandId == ECmdStartCase )

        {

        HandleStartCaseCmdL();

        }

    else if ( iCommandId == ECmdCancelCase )

        {

        HandleCancelCaseCmdL();

        }

    else if ( iCommandId == ECmdPauseCase )

        {

        HandlePauseCaseCmdL();

        }

    else if ( iCommandId == ECmdResumeCase )

        {

        HandleResumeCaseCmdL();

        }

    else if ( iCommandId == ECmdAddCaseFile )

        {

        HandleAddCaseFileCmdL();

        }

    else if ( iCommandId == ECmdRemoveCaseFile )

        {

        HandleRemoveCaseFileCmdL();

        }

    else if ( iCommandId == ECmdCaseMsg )

        {

        HandleCaseMsgCmdL();

        }

    else if ( iCommandId == ECmdSetDevId )

        {

        HandleSetDevIdCmdL();

        }

    else if ( iCommandId == ECmdSetAttribute )

        {

        HandleSetAttributeCmdL();

        }

    else if ( iCommandId == ECmdClose )

        {

        HandleCloseCmdL();

        }

    else if ( iCommandId == ECmdOpen )

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrArgument, KErrorAlreadyOpen ) );

        }

    else

        {

        User::LeaveIfError(

            SendErrorResponseMsg( KErrArgument, KErrorUnknownCmd ) );

        }

    HTI_LOG_FUNC_OUT( "CHtiStifTfIf::ProcessMessageL" );

    }

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

// CHtiStifTfIf::HandleOpenCmdL

// Handles opening of the STIF Test Framework.

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

//

void CHtiStifTfIf::HandleOpenCmdL()

    {

    HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleOpenCmdL" );

    TInt err = KErrNone;

    // OPEN command has 1 optional parameter (test framework ini-file)

    if ( iParameters->Count() == 0 )

        {

        err = Open();

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorOpen );

            return;

            }

        iStifTfOpen = ETrue;

        SendResponseMsg( _L8( "OK" ) );

        }

    else if ( iParameters->Count() == 1 )

        {

        TBuf<KMaxFileName> iniFilePath;

        if ( (*iParameters)[0].Length() > iniFilePath.MaxLength() )

            {

            SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

            return;

            }

        iniFilePath.Copy( (*iParameters)[0] );

        RFs fsSession;

        err = fsSession.Connect();

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorFileServer );

            return;

            }

        if ( !( BaflUtils::FileExists( fsSession, iniFilePath ) ) )

            {

            SendErrorResponseMsg( KErrNotFound, KErrorIniFileNotFound );

            fsSession.Close();

            return;

            }

        fsSession.Close();

        err = Open( iniFilePath );

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorOpen );

            return;

            }

        // Load the test case infos of all currently loaded test

        // modules (modules listed in the given ini-file).

        TRAP( err, LoadTestCaseInfosL() );

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorGetTestCaseInfos );

            return;

            }

        iStifTfOpen = ETrue;

        SendResponseMsg( _L8( "OK" ) );

        }

    else

        {

        SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

        }

    HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleOpenCmdL" );

    }

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

// CHtiStifTfIf::HandleCloseCmdL

// Closes the STIF Test Framework.

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

//

void CHtiStifTfIf::HandleCloseCmdL()

    {

    HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleCloseCmdL" );

    TInt err = KErrNone;

    // CLOSE command has no parameters

    if ( iParameters->Count() == 0 )

        {

        err = Close();

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorClose );

            return;

            }

        iStifTfOpen = EFalse;

        iLoadedInfos.ResetAndDestroy(); // empty the cache of test case infos

        SendResponseMsg( _L8( "OK" ) );

        }

    else

        {

        SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

        }

    HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleCloseCmdL" );

    }

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

// CHtiStifTfIf::HandleLoadModuleCmdL

// Loads a STIF TF test module (optionally with ini-file).

// Also calls the LoadTestCaseInfosL helper method to load the test case info

// objects from the test module.

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

//

void CHtiStifTfIf::HandleLoadModuleCmdL()

    {

    HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleLoadModuleCmdL" );

    TInt err = KErrNone;

    TBuf<KMaxFileName> moduleName;

    TBuf<KMaxFileName> iniFilePath;

    // LOAD_MODULE command has 1 mandatory parameter (module name)

    // and 1 optional parameter (ini-file path).

    if ( iParameters->Count() == 0 )

        {

        SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

        return;

        }

    else if ( iParameters->Count() == 1 )

        {

        if ( (*iParameters)[0].Length() > moduleName.MaxLength() )

            {

            SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

            return;

            }

        moduleName.Copy( (*iParameters)[0] );

        err = AddTestModule( moduleName );

        }

    else if ( iParameters->Count() == 2 )

        {

        if ( (*iParameters)[0].Length() > moduleName.MaxLength() ||

             (*iParameters)[1].Length() > iniFilePath.MaxLength() )

            {

            SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

            return;

            }

        moduleName.Copy( (*iParameters)[0] );

        iniFilePath.Copy( (*iParameters)[1] );

        RFs fsSession;

        err = fsSession.Connect();

        if ( err )

            {

            SendErrorResponseMsg( err, KErrorFileServer );

            return;

            }

        if ( !( BaflUtils::FileExists( fsSession, iniFilePath ) ) )

            {

            SendErrorResponseMsg( KErrNotFound, KErrorIniFileNotFound );

            fsSession.Close();

            return;

            }

        fsSession.Close();

        err = AddTestModule( moduleName, iniFilePath );

        }

    else

        {

        SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

        return;

        }

    if ( err )

        {

        HTI_LOG_FORMAT( "LoadModule: Error %d", err );

        SendErrorResponseMsg( err, KErrorLoadModule );

        }

    else

        {

        TRAP( err, LoadTestCaseInfosL( moduleName ) );

        if ( err )

            {

            HTI_LOG_FORMAT(

                "LoadModule - Error from LoadTestCaseInfosL %d", err );

            RemoveTestModule( moduleName );

            SendErrorResponseMsg( err, KErrorGetTestCases );

            return;

            }

        // Sends the name of the loaded module as a response.

        SendResponseMsg( (*iParameters)[0] );

        }

    HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleLoadModuleCmdL" );

    }

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

// CHtiStifTfIf::HandleUnloadModuleCmdL

// Unloads a STIF TF test module.

// Also removes and deletes the corresponding CHtiTestModuleCaseInfos object